database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-07-30 19:23:07 +03:00
Code Activity

MCOL-317 Remove libdrizzle

Browse Source 
This switches to MariaDB's client library instead of libdrizzle for
Cross Engine and query stats.

It also switches to unbuffered result sets.
This commit is contained in:
Andrew Hutchings
2017-01-12 17:12:39 +00:00
parent 605f6c51e2
commit 3299a3d57d
69 changed files with 112 additions and 13884 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
CMakeLists.txt
View File

@ -57,7 +57,7 @@ SET(CMAKE_SKIP_BUILD_RPATH FALSE)
# (but later on when installing)
SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
SET(CMAKE_INSTALL_RPATH "${INSTALL_ENGINE}/lib")
SET(CMAKE_INSTALL_RPATH "${INSTALL_ENGINE}/lib;${INSTALL_ENGINE}/mysql/lib")
# add the automatically determined parts of the RPATH
# which point to directories outside the build tree to the install RPATH
@ -69,6 +69,11 @@ IF("${isSystemDir}" STREQUAL "-1")
SET(CMAKE_INSTALL_RPATH "${INSTALL_ENGINE}/lib")
ENDIF("${isSystemDir}" STREQUAL "-1")
LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${SERVER_SOURCE_ROOT_DIR}/libmysql/" isSystemDir)
IF("${isSystemDir}" STREQUAL "-1")
SET(CMAKE_INSTALL_RPATH "${INSTALL_ENGINE}/mysql/lib")
ENDIF("${isSystemDir}" STREQUAL "-1")
INCLUDE (configureEngine.cmake)
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/releasenum.in ${CMAKE_CURRENT_BINARY_DIR}/build/releasenum @ONLY IMMEDIATE)
@ -125,7 +130,7 @@ SET (ENGINE_TOOLSDIR "${INSTALL_ENGINE}/tools")
SET (ENGINE_COMMON_LIBS messageqcpp loggingcpp configcpp idbboot ${Boost_LIBRARIES} xml2 pthread rt)
SET (ENGINE_OAM_LIBS oamcpp alarmmanager)
SET (ENGINE_BRM_LIBS brm idbdatafile cacheutils rwlock ${ENGINE_OAM_LIBS} ${ENGINE_COMMON_LIBS})
SET (ENGINE_EXEC_LIBS joblist execplan windowfunction joiner rowgroup funcexp udfsdk dataconvert common compress mysqlcl_idb querystats querytele thrift threadpool ${ENGINE_BRM_LIBS})
SET (ENGINE_EXEC_LIBS joblist execplan windowfunction joiner rowgroup funcexp udfsdk dataconvert common compress querystats querytele thrift threadpool ${ENGINE_BRM_LIBS})
SET (ENGINE_WRITE_LIBS ddlpackageproc ddlpackage dmlpackageproc dmlpackage writeengine writeengineclient idbdatafile cacheutils ${ENGINE_EXEC_LIBS})
SET (ENGINE_COMMON_LDFLAGS "")

2
dbcon/joblist/CMakeLists.txt
View File

@ -61,7 +61,7 @@ set(joblist_LIB_SRCS
add_library(joblist SHARED ${joblist_LIB_SRCS})
target_link_libraries(joblist ${NETSNMP_LIBRARIES})
target_link_libraries(joblist ${NETSNMP_LIBRARIES} -L${SERVER_SOURCE_ROOT_DIR}/libmysql/ libmysqlclient_r.so)
set_target_properties(joblist PROPERTIES VERSION 1.0.0 SOVERSION 1)

100
dbcon/joblist/crossenginestep.cpp
View File

@ -17,6 +17,7 @@
// $Id: crossenginestep.cpp 9709 2013-07-20 06:08:46Z xlou $
#include "crossenginestep.h"
#include <unistd.h>
//#define NDEBUG
#include <cassert>
@ -55,89 +56,68 @@ using namespace querytele;
#include "jobstep.h"
#include "jlf_common.h"
#include "crossenginestep.h"
#include "libdrizzle-2.0/drizzle.h"
#include "libdrizzle-2.0/drizzle_client.h"
namespace joblist
{
DrizzleMySQL::DrizzleMySQL() : fDrzp(NULL), fDrzcp(NULL), fDrzrp(NULL)
LibMySQL::LibMySQL() : fCon(NULL), fRes(NULL)
{
}
DrizzleMySQL::~DrizzleMySQL()
LibMySQL::~LibMySQL()
{
if (fDrzrp)
if (fRes)
{
drizzle_result_free(fDrzrp);
mysql_free_result(fRes);
}
fDrzrp = NULL;
fRes = NULL;
if (fDrzcp)
if (fCon)
{
drizzle_con_close(fDrzcp);
drizzle_con_free(fDrzcp);
mysql_close(fCon);
}
fDrzcp = NULL;
if (fDrzp)
{
drizzle_free(fDrzp);
}
fDrzp = NULL;
fCon = NULL;
}
int DrizzleMySQL::init(const char* h, unsigned int p, const char* u, const char* w, const char* d)
int LibMySQL::init(const char* h, unsigned int p, const char* u, const char* w, const char* d)
{
int ret = -1;
int ret = 0;
fDrzp = drizzle_create();
if (fDrzp != NULL)
fCon = mysql_init(NULL);
if (fCon != NULL)
{
fDrzcp = drizzle_con_add_tcp(fDrzp, h, p, u, w, d, DRIZZLE_CON_MYSQL);
if (fDrzcp != NULL)
if (mysql_real_connect(fCon, h, u, w, d, p, NULL, 0) == NULL)
{
ret = drizzle_con_connect(fDrzcp);
if (ret != 0)
fErrStr = "fatal error in drizzle_con_connect()";
}
else
{
fErrStr = "fatal error in drizzle_con_add_tcp()";
fErrStr = "fatal error in mysql_real_connect()";
ret = mysql_errno(fCon);
}
}
else
{
fErrStr = "fatal error in drizzle_create()";
fErrStr = "fatal error in mysql_init()";
ret = -1;
}
return ret;
}
int DrizzleMySQL::run(const char* query)
int LibMySQL::run(const char* query)
{
int ret = 0;
drizzle_return_t drzret;
fDrzrp = drizzle_query_str(fDrzcp, fDrzrp, query, &drzret);
if (drzret == 0 && fDrzrp != NULL)
if (mysql_query(fCon, query) != 0)
{
ret = drzret = drizzle_result_buffer(fDrzrp);
if (drzret != 0)
fErrStr = "fatal error reading result from crossengine client lib";
}
else
{
fErrStr = "fatal error executing query in crossengine client lib";
if (drzret != 0)
ret = drzret;
else
ret = -1;
fErrStr = "fatal error reading result from crossengine client lib";
ret = -1;
}
fRes = mysql_use_result(fCon);
if (fRes == NULL)
{
fErrStr = "fatal error reading result from crossengine client lib";
ret = -1;
}
return ret;
}
@ -164,13 +144,13 @@ CrossEngineStep::CrossEngineStep(
fExtendedInfo = "CES: ";
getMysqldInfo(jobInfo);
fQtc.stepParms().stepType = StepTeleStats::T_CES;
drizzle = new DrizzleMySQL();
mysql = new LibMySQL();
}
CrossEngineStep::~CrossEngineStep()
{
delete drizzle;
delete mysql;
}
@ -463,20 +443,20 @@ void CrossEngineStep::execute()
sts.total_units_of_work = 1;
postStepStartTele(sts);
ret = drizzle->init(fHost.c_str(), fPort, fUser.c_str(), fPasswd.c_str(), fSchema.c_str());
ret = mysql->init(fHost.c_str(), fPort, fUser.c_str(), fPasswd.c_str(), fSchema.c_str());
if (ret != 0)
handleMySqlError(drizzle->getError().c_str(), ret);
handleMySqlError(mysql->getError().c_str(), ret);
string query(makeQuery());
fLogger->logMessage(logging::LOG_TYPE_INFO, "QUERY to foreign engine: " + query);
if (traceOn())
cout << "QUERY: " << query << endl;
ret = drizzle->run(query.c_str());
ret = mysql->run(query.c_str());
if (ret != 0)
handleMySqlError(drizzle->getError().c_str(), ret);
handleMySqlError(mysql->getError().c_str(), ret);
int num_fields = drizzle->getFieldCount();
int num_fields = mysql->getFieldCount();
char** rowIn; // input
//shared_array<uint8_t> rgDataDelivered; // output
@ -497,7 +477,7 @@ void CrossEngineStep::execute()
bool doFE3 = (fFeSelects.size() > 0);
if (!doFE1 && !doFE3)
{
while ((rowIn = drizzle->nextRow()) && !cancelled())
while ((rowIn = mysql->nextRow()) && !cancelled())
{
for(int i = 0; i < num_fields; i++)
setField(i, rowIn[i], fRowDelivered);
@ -514,7 +494,7 @@ void CrossEngineStep::execute()
rgDataFe1.reset(new uint8_t[rowFe1.getSize()]);
rowFe1.setData(rgDataFe1.get());
while ((rowIn = drizzle->nextRow()) && !cancelled())
while ((rowIn = mysql->nextRow()) && !cancelled())
{
// Parse the columns used in FE1 first, the other column may not need be parsed.
for(int i = 0; i < num_fields; i++)
@ -549,7 +529,7 @@ void CrossEngineStep::execute()
rgDataFe3.reset(new uint8_t[rowFe3.getSize()]);
rowFe3.setData(rgDataFe3.get());
while ((rowIn = drizzle->nextRow()) && !cancelled())
while ((rowIn = mysql->nextRow()) && !cancelled())
{
for(int i = 0; i < num_fields; i++)
setField(i, rowIn[i], rowFe3);
@ -577,7 +557,7 @@ void CrossEngineStep::execute()
rgDataFe3.reset(new uint8_t[rowFe3.getSize()]);
rowFe3.setData(rgDataFe3.get());
while ((rowIn = drizzle->nextRow()) && !cancelled())
while ((rowIn = mysql->nextRow()) && !cancelled())
{
// Parse the columns used in FE1 first, the other column may not need be parsed.
for(int i = 0; i < num_fields; i++)
@ -609,7 +589,7 @@ void CrossEngineStep::execute()
//INSERT_ADAPTER(fOutputDL, rgDataDelivered);
fOutputDL->insert(rgDataDelivered);
fRowsRetrieved = drizzle->getRowCount();
fRowsRetrieved = mysql->getRowCount();
}
catch (IDBExcept& iex)
{

29
dbcon/joblist/crossenginestep.h
View File

@ -21,13 +21,15 @@
#ifndef JOBLIST_CROSSENGINESTEP_H
#define JOBLIST_CROSSENGINESTEP_H
#include <my_config.h>
#include <mysql.h>
#include <boost/scoped_array.hpp>
#include "jobstep.h"
#include "primitivestep.h"
#include "libdrizzle-2.0/drizzle.h"
#include "libdrizzle-2.0/drizzle_client.h"
using namespace std;
// forward reference
namespace execplan
@ -44,11 +46,11 @@ class FuncExp;
namespace joblist
{
class DrizzleMySQL
class LibMySQL
{
public:
DrizzleMySQL();
~DrizzleMySQL();
LibMySQL();
~LibMySQL();
// init: host port username passwd db
int init(const char*, unsigned int, const char*, const char*, const char*);
@ -56,16 +58,15 @@ public:
// run the query
int run(const char* q);
int getFieldCount() { return drizzle_result_column_count(fDrzrp); }
int getRowCount() { return drizzle_result_row_count(fDrzrp); }
char** nextRow() { return drizzle_row_next(fDrzrp); }
const string& getError() { return fErrStr; }
int getFieldCount() { return mysql_num_fields(fRes); }
int getRowCount() { return mysql_num_rows(fRes); }
char** nextRow() { return mysql_fetch_row(fRes); }
const std::string& getError() { return fErrStr; }
private:
drizzle_st* fDrzp;
drizzle_con_st* fDrzcp;
drizzle_result_st* fDrzrp;
string fErrStr;
MYSQL* fCon;
MYSQL_RES* fRes;
std::string fErrStr;
};
/** @brief class CrossEngineStep
@ -212,7 +213,7 @@ protected:
rowgroup::RowGroup fRowGroupFe3;
funcexp::FuncExp* fFeInstance;
DrizzleMySQL* drizzle;
LibMySQL* mysql;
};

3
dbcon/joblist/jlf_graphics.cpp
View File

@ -17,12 +17,13 @@
// $Id: jlf_graphics.cpp 9550 2013-05-17 23:58:07Z xlou $
// Cross engine at the top due to MySQL includes
#include "crossenginestep.h"
#include <iostream>
using namespace std;
#include "joblist.h"
#include "primitivestep.h"
#include "crossenginestep.h"
#include "subquerystep.h"
#include "windowfunctionstep.h"
#include "tupleaggregatestep.h"

4
dbcon/joblist/jlf_tuplejoblist.cpp
View File

@ -17,7 +17,8 @@
// $Id: jlf_tuplejoblist.cpp 9728 2013-07-26 22:08:20Z xlou $
// Cross engine needs to be at the top due to MySQL includes
#include "crossenginestep.h"
#include <iostream>
#include <stack>
#include <iterator>
@ -55,7 +56,6 @@ using namespace dataconvert;
#include "limitedorderby.h"
#include "jobstep.h"
#include "primitivestep.h"
#include "crossenginestep.h"
#include "expressionstep.h"
#include "subquerystep.h"
#include "tupleaggregatestep.h"

4
dbcon/joblist/joblist.cpp
View File

@ -18,7 +18,8 @@
// $Id: joblist.cpp 9655 2013-06-25 23:08:13Z xlou $
// Cross engine needs to be at the top due to MySQL includes
#include "crossenginestep.h"
#include "errorcodes.h"
#include <iterator>
#include <stdexcept>
@ -34,7 +35,6 @@ using namespace execplan;
#include "errorids.h"
#include "jobstep.h"
#include "primitivestep.h"
#include "crossenginestep.h"
#include "subquerystep.h"
#include "tupleaggregatestep.h"
#include "tupleannexstep.h"

4
dbcon/joblist/tupleaggregatestep.cpp
View File

@ -19,6 +19,9 @@
//#define NDEBUG
// Cross engine needs to be at top due to MySQL includes
#include "crossenginestep.h"
#include <cassert>
#include <sstream>
#include <iomanip>
@ -61,7 +64,6 @@ using namespace querytele;
#include "primitivestep.h"
#include "subquerystep.h"
#include "tuplehashjoin.h"
#include "crossenginestep.h"
#include "tupleaggregatestep.h"
//#include "stopwatch.cpp"

1
utils/CMakeLists.txt
View File

@ -16,7 +16,6 @@ add_subdirectory(udfsdk)
add_subdirectory(compress)
add_subdirectory(batchloader)
add_subdirectory(ddlcleanup)
add_subdirectory(mysqlcl_idb)
add_subdirectory(querystats)
add_subdirectory(windowfunction)
add_subdirectory(idbdatafile)

27
utils/mysqlcl_idb/CMakeLists.txt
View File

@ -1,27 +0,0 @@
include_directories( /usr/include/libxml2 ${ENGINE_COMMON_INCLUDES} )
########### next target ###############
set(mysqlcl_idb_LIB_SRCS
column.cc
command.cc
conn.cc
conn_uds.cc
drizzle.cc
field.cc
handshake.cc
pack.cc
query.cc
result.cc
row.cc
sha1.cc
state.cc)
add_library(mysqlcl_idb SHARED ${mysqlcl_idb_LIB_SRCS})
set_target_properties(mysqlcl_idb PROPERTIES VERSION 1.0.0 SOVERSION 1)
install(TARGETS mysqlcl_idb DESTINATION ${ENGINE_LIBDIR} COMPONENT libs)

54
utils/mysqlcl_idb/Makefile.am
View File

@ -1,54 +0,0 @@
# Copyright (C) 2014 InfiniDB, Inc.
#
# 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; version 2 of
# the License.
#
# 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., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
# $Id$
## Process this file with automake to produce Makefile.in
AM_CPPFLAGS = $(idb_common_includes) $(idb_cppflags)
AM_CFLAGS = $(idb_cflags)
AM_CXXFLAGS = $(idb_cxxflags)
AM_LDFLAGS = -version-info 1:0:0 $(idb_ldflags)
lib_LTLIBRARIES = libmysqlcl_idb.la
libmysqlcl_idb_la_CPPFLAGS = -I/usr/include/libxml2 $(AM_CPPFLAGS)
libmysqlcl_idb_la_SOURCES = \
column.cc \
command.cc \
conn.cc \
conn_uds.cc \
drizzle.cc \
field.cc \
handshake.cc \
pack.cc \
query.cc \
result.cc \
row.cc \
sha1.cc \
state.cc
include_HEADERS =
test:
coverage:
leakcheck:
docs:
bootstrap: install-data-am
install-data-hook:
cp -Rpf libdrizzle-2.0 $(DESTDIR)$(includedir)

1208
utils/mysqlcl_idb/column.cc
View File

File diff suppressed because it is too large Load Diff

254
utils/mysqlcl_idb/command.cc
View File

@ -1,254 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Command definitions
*/
#include <libdrizzle-2.0/common.h>
/*
* Private variables.
*/
static drizzle_command_drizzle_t _command_drizzle_map[]=
{
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_QUIT,
DRIZZLE_COMMAND_DRIZZLE_INIT_DB,
DRIZZLE_COMMAND_DRIZZLE_QUERY,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_SHUTDOWN,
DRIZZLE_COMMAND_DRIZZLE_END, // STATISTICS
DRIZZLE_COMMAND_DRIZZLE_END, // PROCESS_INFO
DRIZZLE_COMMAND_DRIZZLE_END, // CONNECT
DRIZZLE_COMMAND_DRIZZLE_KILL,// PROCESS_KILL
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_PING,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END,
DRIZZLE_COMMAND_DRIZZLE_END
};
/*
* State Definitions
*/
drizzle_return_t drizzle_state_command_read(drizzle_con_st *con)
{
drizzle_log_debug(con->drizzle, "drizzle_state_command_read");
if (con->buffer_size == 0)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
if (con->command_total == 0)
{
con->command= (drizzle_command_t)(con->buffer_ptr[0]);
con->buffer_ptr++;
con->buffer_size--;
con->command_total= (con->packet_size - 1);
}
if (con->buffer_size < (con->command_total - con->command_offset))
{
con->command_size= con->buffer_size;
con->command_offset+= con->command_size;
}
else
{
con->command_size= (con->command_total - con->command_offset);
con->command_offset= con->command_total;
}
con->command_data= con->buffer_ptr;
con->buffer_ptr+= con->command_size;
con->buffer_size-= con->command_size;
if (con->command_offset == con->command_total)
{
drizzle_state_pop(con);
}
else
{
return DRIZZLE_RETURN_PAUSE;
}
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_command_write(drizzle_con_st *con)
{
uint8_t *start;
uint8_t *ptr;
size_t free_size;
drizzle_return_t ret;
drizzle_log_debug(con->drizzle, "drizzle_state_command_write");
if (con->command_data == NULL && con->command_total != 0 &&
con->command != DRIZZLE_COMMAND_CHANGE_USER)
{
return DRIZZLE_RETURN_PAUSE;
}
if (con->buffer_size == 0)
{
con->buffer_ptr= con->buffer;
start= con->buffer;
}
else
start= con->buffer_ptr + con->buffer_size;
if (con->command_offset == 0)
{
/* Make sure we can fit the largest non-streaming packet, currently a
DRIZZLE_COMMAND_CHANGE_USER command. */
con->packet_size= 1 /* Command */
+ strlen(con->user) + 1
+ 1 /* Scramble size */
+ DRIZZLE_MAX_SCRAMBLE_SIZE
+ strlen(con->schema) +1;
/* Flush buffer if there is not enough room. */
free_size= (size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer);
if (free_size < con->packet_size)
{
drizzle_state_push(con, drizzle_state_write);
return DRIZZLE_RETURN_OK;
}
/* Store packet size at the end since it may change. */
con->packet_number= 1;
ptr= start;
ptr[3]= 0;
if (con->options & DRIZZLE_CON_MYSQL)
{
ptr[4]= uint8_t(con->command);
}
else
{
ptr[4]= uint8_t(_command_drizzle_map[con->command]);
}
ptr+= 5;
if (con->command == DRIZZLE_COMMAND_CHANGE_USER)
{
ptr= drizzle_pack_auth(con, ptr, &ret);
if (ret != DRIZZLE_RETURN_OK)
return ret;
con->buffer_size+= (4 + con->packet_size);
}
else if (con->command_total == 0)
{
con->packet_size= 1;
con->buffer_size+= 5;
}
else
{
con->packet_size= 1 + con->command_total;
free_size-= 5;
/* Copy as much of the data in as we can into the write buffer. */
if (con->command_size <= free_size)
{
memcpy(ptr, con->command_data, con->command_size);
con->command_offset= con->command_size;
con->command_data= NULL;
con->buffer_size+= 5 + con->command_size;
}
else
{
memcpy(ptr, con->command_data, free_size);
con->command_offset= free_size;
con->command_data+= free_size;
con->command_size-= free_size;
con->buffer_size+= 5 + free_size;
}
}
/* Store packet size now. */
drizzle_set_byte3(start, con->packet_size);
}
else
{
/* Write directly from the caller buffer for the rest. */
con->buffer_ptr= con->command_data;
con->buffer_size= con->command_size;
con->command_offset+= con->command_size;
con->command_data= NULL;
}
if (con->command_offset == con->command_total)
{
drizzle_state_pop(con);
if (!(con->options & (DRIZZLE_CON_RAW_PACKET |
DRIZZLE_CON_NO_RESULT_READ)) &&
con->command != DRIZZLE_COMMAND_FIELD_LIST)
{
drizzle_state_push(con, drizzle_state_result_read);
drizzle_state_push(con, drizzle_state_packet_read);
}
}
drizzle_state_push(con, drizzle_state_write);
return DRIZZLE_RETURN_OK;
}

1733
utils/mysqlcl_idb/conn.cc
View File

File diff suppressed because it is too large Load Diff

79
utils/mysqlcl_idb/conn_uds.cc
View File

@ -1,79 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Connection Definitions for Unix Domain Sockets
*/
#include <libdrizzle-2.0/common.h>
const char *drizzle_con_uds(const drizzle_con_st *con)
{
if (con->socket_type == DRIZZLE_CON_SOCKET_UDS)
{
if (con->socket.uds.sockaddr.sun_path[0] != 0)
return con->socket.uds.sockaddr.sun_path;
if (con->options & DRIZZLE_CON_MYSQL)
return DRIZZLE_DEFAULT_UDS_MYSQL;
return DRIZZLE_DEFAULT_UDS;
}
return NULL;
}
void drizzle_con_set_uds(drizzle_con_st *con, const char *uds)
{
drizzle_con_reset_addrinfo(con);
con->socket_type= DRIZZLE_CON_SOCKET_UDS;
if (uds == NULL)
uds= "";
con->socket.uds.sockaddr.sun_family= AF_UNIX;
strncpy(con->socket.uds.sockaddr.sun_path, uds,
sizeof(con->socket.uds.sockaddr.sun_path));
con->socket.uds.sockaddr.sun_path[sizeof(con->socket.uds.sockaddr.sun_path) - 1]= 0;
con->socket.uds.addrinfo.ai_family= AF_UNIX;
con->socket.uds.addrinfo.ai_socktype= SOCK_STREAM;
con->socket.uds.addrinfo.ai_protocol= 0;
con->socket.uds.addrinfo.ai_addrlen= sizeof(struct sockaddr_un);
con->socket.uds.addrinfo.ai_addr= (struct sockaddr *)&(con->socket.uds.sockaddr);
}

761
utils/mysqlcl_idb/drizzle.cc
View File

@ -1,761 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Drizzle Definitions
*/
#include <libdrizzle-2.0/common.h>
/**
* @addtogroup drizzle_static Static Drizzle Declarations
* @ingroup drizzle
* @{
*/
/**
* Names of the verbose levels provided.
*/
static const char *_verbose_name[DRIZZLE_VERBOSE_MAX]=
{
"NEVER",
"FATAL",
"ERROR",
"INFO",
"DEBUG",
"CRAZY"
};
/** @} */
/*
* Common Definitions
*/
const char *drizzle_version()
{
return PACKAGE_VERSION;
}
const char *drizzle_bugreport()
{
return PACKAGE_BUGREPORT;
}
const char *drizzle_verbose_name(drizzle_verbose_t verbose)
{
if (verbose >= DRIZZLE_VERBOSE_MAX)
{
return "UNKNOWN";
}
return _verbose_name[verbose];
}
drizzle_st *drizzle_create()
{
#if defined(_WIN32)
/* if it is MS windows, invoke WSAStartup */
WSADATA wsaData;
if ( WSAStartup( MAKEWORD(2,2), &wsaData ) != 0 )
printf("Error at WSAStartup()\n");
#else
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &act, NULL);
#endif
drizzle_st *drizzle= new (std::nothrow) drizzle_st;
if (drizzle == NULL)
{
return NULL;
}
/* @todo remove this default free flag with new API. */
drizzle->options.is_free_objects= true;
drizzle->error_code= 0;
/* drizzle->options set above */
drizzle->verbose= DRIZZLE_VERBOSE_NEVER;
drizzle->con_count= 0;
drizzle->pfds_size= 0;
drizzle->query_count= 0;
drizzle->query_new= 0;
drizzle->query_running= 0;
drizzle->last_errno= 0;
drizzle->timeout= -1;
drizzle->con_list= NULL;
drizzle->context= NULL;
drizzle->context_free_fn= NULL;
drizzle->event_watch_fn= NULL;
drizzle->event_watch_context= NULL;
drizzle->log_fn= NULL;
drizzle->log_context= NULL;
drizzle->pfds= NULL;
drizzle->query_list= NULL;
drizzle->sqlstate[0]= 0;
drizzle->last_error[0]= 0;
return drizzle;
}
drizzle_st *drizzle_clone(const drizzle_st *source)
{
drizzle_st *drizzle= drizzle_create();
if (drizzle == NULL)
{
return NULL;
}
for (drizzle_con_st* con= source->con_list; con != NULL; con= con->next)
{
if (drizzle_con_clone(drizzle, con) == NULL)
{
drizzle_free(drizzle);
return NULL;
}
}
return drizzle;
}
void drizzle_free(drizzle_st *drizzle)
{
if (drizzle->context != NULL && drizzle->context_free_fn != NULL)
{
drizzle->context_free_fn(drizzle, drizzle->context);
}
if (drizzle->options.is_free_objects)
{
drizzle_con_free_all(drizzle);
drizzle_query_free_all(drizzle);
}
else if (drizzle->options.is_assert_dangling)
{
assert(drizzle->con_list == NULL);
assert(drizzle->query_list == NULL);
}
free(drizzle->pfds);
delete drizzle;
#if defined(_WIN32)
/* if it is MS windows, invoke WSACleanup() at the end*/
WSACleanup();
#endif
}
const char *drizzle_error(const drizzle_st *drizzle)
{
return drizzle->last_error;
}
drizzle_return_t drizzle_set_option(drizzle_st *drizzle, drizzle_options_t arg, bool set)
{
switch (arg)
{
case DRIZZLE_NON_BLOCKING:
drizzle->options.is_non_blocking= set;
return DRIZZLE_RETURN_OK;
case DRIZZLE_FREE_OBJECTS:
return DRIZZLE_RETURN_OK;
case DRIZZLE_ASSERT_DANGLING:
return DRIZZLE_RETURN_OK;
default:
break;
}
return DRIZZLE_RETURN_INVALID_ARGUMENT;
}
int drizzle_errno(const drizzle_st *drizzle)
{
return drizzle->last_errno;
}
uint16_t drizzle_error_code(const drizzle_st *drizzle)
{
return drizzle->error_code;
}
const char *drizzle_sqlstate(const drizzle_st *drizzle)
{
return drizzle->sqlstate;
}
void *drizzle_context(const drizzle_st *drizzle)
{
return drizzle->context;
}
void drizzle_set_context(drizzle_st *drizzle, void *context)
{
drizzle->context= context;
}
void drizzle_set_context_free_fn(drizzle_st *drizzle,
drizzle_context_free_fn *function)
{
drizzle->context_free_fn= function;
}
int drizzle_timeout(const drizzle_st *drizzle)
{
return drizzle->timeout;
}
void drizzle_set_timeout(drizzle_st *drizzle, int timeout)
{
drizzle->timeout= timeout;
}
drizzle_verbose_t drizzle_verbose(const drizzle_st *drizzle)
{
return drizzle->verbose;
}
void drizzle_set_verbose(drizzle_st *drizzle, drizzle_verbose_t verbose)
{
drizzle->verbose= verbose;
}
void drizzle_set_log_fn(drizzle_st *drizzle, drizzle_log_fn *function,
void *context)
{
drizzle->log_fn= function;
drizzle->log_context= context;
}
void drizzle_set_event_watch_fn(drizzle_st *drizzle,
drizzle_event_watch_fn *function,
void *context)
{
drizzle->event_watch_fn= function;
drizzle->event_watch_context= context;
}
drizzle_con_st *drizzle_con_create(drizzle_st *drizzle)
{
if (drizzle == NULL)
{
return NULL;
}
drizzle_con_st *con= new (std::nothrow) drizzle_con_st;
if (con == NULL)
{
return NULL;
}
if (drizzle->con_list != NULL)
{
drizzle->con_list->prev= con;
}
con->next= drizzle->con_list;
con->prev= NULL;
drizzle->con_list= con;
drizzle->con_count++;
con->packet_number= 0;
con->protocol_version= 0;
con->state_current= 0;
con->events= 0;
con->revents= 0;
con->capabilities= DRIZZLE_CAPABILITIES_NONE;
con->charset= 0;
con->command= DRIZZLE_COMMAND_SLEEP;
con->options|= DRIZZLE_CON_MYSQL;
con->socket_type= DRIZZLE_CON_SOCKET_TCP;
con->status= DRIZZLE_CON_STATUS_NONE;
con->max_packet_size= DRIZZLE_MAX_PACKET_SIZE;
con->result_count= 0;
con->thread_id= 0;
con->backlog= DRIZZLE_DEFAULT_BACKLOG;
con->fd= -1;
con->buffer_size= 0;
con->command_offset= 0;
con->command_size= 0;
con->command_total= 0;
con->packet_size= 0;
con->addrinfo_next= NULL;
con->buffer_ptr= con->buffer;
con->command_buffer= NULL;
con->command_data= NULL;
con->context= NULL;
con->context_free_fn= NULL;
con->drizzle= drizzle;
/* con->next set above */
/* con->prev set above */
con->query= NULL;
/* con->result doesn't need to be set */
con->result_list= NULL;
con->scramble= NULL;
con->socket.tcp.addrinfo= NULL;
con->socket.tcp.host= NULL;
con->socket.tcp.port= 0;
/* con->buffer doesn't need to be set */
con->schema[0]= 0;
con->password[0]= 0;
/* con->scramble_buffer doesn't need to be set */
con->server_version[0]= 0;
/* con->state_stack doesn't need to be set */
con->user[0]= 0;
return con;
}
drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *source)
{
drizzle_con_st *con= drizzle_con_create(drizzle);
if (con == NULL)
{
return NULL;
}
/* Clear "operational" options such as IO status. */
con->options|= (source->options & ~(DRIZZLE_CON_ALLOCATED|DRIZZLE_CON_READY|
DRIZZLE_CON_NO_RESULT_READ|DRIZZLE_CON_IO_READY|
DRIZZLE_CON_LISTEN));
con->backlog= source->backlog;
strcpy(con->schema, source->schema);
strcpy(con->password, source->password);
strcpy(con->user, source->user);
switch (source->socket_type)
{
case DRIZZLE_CON_SOCKET_TCP:
drizzle_con_set_tcp(con, source->socket.tcp.host, source->socket.tcp.port);
break;
case DRIZZLE_CON_SOCKET_UDS:
drizzle_con_set_uds(con, source->socket.uds.sockaddr.sun_path);
break;
}
return con;
}
void drizzle_con_free(drizzle_con_st *con)
{
if (con->context != NULL && con->context_free_fn != NULL)
{
con->context_free_fn(con, con->context);
}
if (con->drizzle->options.is_free_objects)
{
drizzle_result_free_all(con);
}
else if (con->drizzle->options.is_assert_dangling)
{
assert(con->result_list == NULL);
}
if (con->fd != -1)
{
drizzle_con_close(con);
}
drizzle_con_reset_addrinfo(con);
if (con->drizzle->con_list == con)
{
con->drizzle->con_list= con->next;
}
if (con->prev != NULL)
{
con->prev->next= con->next;
}
if (con->next != NULL)
{
con->next->prev= con->prev;
}
con->drizzle->con_count--;
delete con;
}
void drizzle_con_free_all(drizzle_st *drizzle)
{
while (drizzle->con_list != NULL)
{
drizzle_con_free(drizzle->con_list);
}
}
drizzle_return_t drizzle_con_wait(drizzle_st *drizzle)
{
struct pollfd *pfds;
int ret;
drizzle_return_t dret;
if (drizzle->pfds_size < drizzle->con_count)
{
pfds= (struct pollfd *)realloc(drizzle->pfds, drizzle->con_count * sizeof(struct pollfd));
if (pfds == NULL)
{
drizzle_set_error(drizzle, "drizzle_con_wait", "realloc");
return DRIZZLE_RETURN_MEMORY;
}
drizzle->pfds= pfds;
drizzle->pfds_size= drizzle->con_count;
}
else
{
pfds= drizzle->pfds;
}
uint32_t x= 0;
for (drizzle_con_st* con= drizzle->con_list; con != NULL; con= con->next)
{
if (con->events == 0)
continue;
pfds[x].fd= con->fd;
pfds[x].events= con->events;
pfds[x].revents= 0;
x++;
}
if (x == 0)
{
drizzle_set_error(drizzle, "drizzle_con_wait",
"no active file descriptors");
return DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS;
}
while (1)
{
drizzle_log_crazy(drizzle, "poll count=%d timeout=%d", x,
drizzle->timeout);
ret= poll(pfds, x, drizzle->timeout);
drizzle_log_crazy(drizzle, "poll return=%d errno=%d", ret, errno);
if (ret == -1)
{
if (errno == EINTR)
continue;
drizzle_set_error(drizzle, "drizzle_con_wait", "poll:%d", errno);
drizzle->last_errno= errno;
return DRIZZLE_RETURN_ERRNO;
}
break;
}
if (ret == 0)
{
drizzle_set_error(drizzle, "drizzle_con_wait", "timeout reached");
return DRIZZLE_RETURN_TIMEOUT;
}
x= 0;
for (drizzle_con_st* con= drizzle->con_list; con != NULL; con= con->next)
{
if (con->events == 0)
continue;
dret= drizzle_con_set_revents(con, pfds[x].revents);
if (dret != DRIZZLE_RETURN_OK)
return dret;
x++;
}
return DRIZZLE_RETURN_OK;
}
drizzle_con_st *drizzle_con_ready(drizzle_st *drizzle)
{
/* We can't keep state between calls since connections may be removed during
processing. If this list ever gets big, we may want something faster. */
for (drizzle_con_st* con= drizzle->con_list; con != NULL; con= con->next)
{
if (con->options & DRIZZLE_CON_IO_READY)
{
con->options&= ~DRIZZLE_CON_IO_READY;
return con;
}
}
return NULL;
}
drizzle_con_st *drizzle_con_ready_listen(drizzle_st *drizzle)
{
/* We can't keep state between calls since connections may be removed during
processing. If this list ever gets big, we may want something faster. */
for (drizzle_con_st* con= drizzle->con_list; con != NULL; con= con->next)
{
if ((con->options & (DRIZZLE_CON_IO_READY | DRIZZLE_CON_LISTEN)) ==
(DRIZZLE_CON_IO_READY | DRIZZLE_CON_LISTEN))
{
con->options&= ~DRIZZLE_CON_IO_READY;
return con;
}
}
return NULL;
}
/*
* Client Definitions
*/
drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle,
const char *host, in_port_t port,
const char *user, const char *password,
const char *db,
drizzle_con_options_t options)
{
drizzle_con_st *con= drizzle_con_create(drizzle);
if (con == NULL)
{
return NULL;
}
drizzle_con_set_tcp(con, host, port);
drizzle_con_set_auth(con, user, password);
drizzle_con_set_db(con, db);
drizzle_con_add_options(con, options);
return con;
}
drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle,
const char *uds, const char *user,
const char *password, const char *db,
drizzle_con_options_t options)
{
drizzle_con_st *con= drizzle_con_create(drizzle);
if (con == NULL)
{
return NULL;
}
drizzle_con_set_uds(con, uds);
drizzle_con_set_auth(con, user, password);
drizzle_con_set_db(con, db);
drizzle_con_add_options(con, options);
return con;
}
/*
* Server Definitions
*/
drizzle_con_st *drizzle_con_add_tcp_listen(drizzle_st *drizzle,
const char *host, in_port_t port,
int backlog,
drizzle_con_options_t options)
{
drizzle_con_st *con= drizzle_con_create(drizzle);
if (con == NULL)
{
return NULL;
}
drizzle_con_set_tcp(con, host, port);
drizzle_con_set_backlog(con, backlog);
drizzle_con_add_options(con, options | DRIZZLE_CON_LISTEN);
return con;
}
drizzle_con_st *drizzle_con_add_uds_listen(drizzle_st *drizzle,
const char *uds, int backlog,
drizzle_con_options_t options)
{
drizzle_con_st *con= drizzle_con_create(drizzle);
if (con == NULL)
{
return NULL;
}
drizzle_con_set_uds(con, uds);
drizzle_con_set_backlog(con, backlog);
drizzle_con_add_options(con, options | DRIZZLE_CON_LISTEN);
return con;
}
drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle,
drizzle_return_t *ret_ptr)
{
drizzle_return_t unused;
if (ret_ptr == NULL)
{
ret_ptr= &unused;
}
while (1)
{
if (drizzle_con_st* ready= drizzle_con_ready_listen(drizzle))
{
int fd= accept(ready->fd, NULL, NULL);
drizzle_con_st *con= drizzle_con_create(drizzle);
if (con == NULL)
{
(void)closesocket(fd);
*ret_ptr= DRIZZLE_RETURN_MEMORY;
return NULL;
}
*ret_ptr= drizzle_con_set_fd(con, fd);
if (*ret_ptr != DRIZZLE_RETURN_OK)
{
(void)closesocket(fd);
return NULL;
}
if (ready->options & DRIZZLE_CON_MYSQL)
drizzle_con_add_options(con, DRIZZLE_CON_MYSQL);
*ret_ptr= DRIZZLE_RETURN_OK;
return con;
}
if (drizzle->options.is_non_blocking)
{
*ret_ptr= DRIZZLE_RETURN_IO_WAIT;
return NULL;
}
for (drizzle_con_st* ready= drizzle->con_list; ready != NULL; ready= ready->next)
{
if (ready->options & DRIZZLE_CON_LISTEN)
{
drizzle_con_set_events(ready, POLLIN);
}
}
*ret_ptr= drizzle_con_wait(drizzle);
if (*ret_ptr != DRIZZLE_RETURN_OK)
{
return NULL;
}
}
}
/*
* Local Definitions
*/
void drizzle_set_error(drizzle_st *drizzle, const char *function,
const char *format, ...)
{
if (drizzle == NULL)
{
return;
}
char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
size_t size= strlen(function);
char* ptr= (char *)memcpy(log_buffer, function, size);
ptr+= size;
ptr[0]= ':';
size++;
ptr++;
va_list args;
va_start(args, format);
int written= vsnprintf(ptr, DRIZZLE_MAX_ERROR_SIZE - size, format, args);
va_end(args);
if (written < 0)
{
size= DRIZZLE_MAX_ERROR_SIZE;
}
else
{
size+= written;
}
if (size >= DRIZZLE_MAX_ERROR_SIZE)
{
size= DRIZZLE_MAX_ERROR_SIZE - 1;
}
log_buffer[size]= 0;
if (drizzle->log_fn == NULL)
{
memcpy(drizzle->last_error, log_buffer, size + 1);
}
else
{
drizzle->log_fn(log_buffer, DRIZZLE_VERBOSE_ERROR, drizzle->log_context);
}
}
void drizzle_log(drizzle_st *drizzle, drizzle_verbose_t verbose,
const char *format, va_list args)
{
char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
if (drizzle == NULL)
{
return;
}
if (drizzle->log_fn == NULL)
{
printf("%5s: ", drizzle_verbose_name(verbose));
vprintf(format, args);
printf("\n");
}
else
{
vsnprintf(log_buffer, DRIZZLE_MAX_ERROR_SIZE, format, args);
log_buffer[DRIZZLE_MAX_ERROR_SIZE-1]= 0;
drizzle->log_fn(log_buffer, verbose, drizzle->log_context);
}
}

396
utils/mysqlcl_idb/field.cc
View File

@ -1,396 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Field definitions
*/
#include <libdrizzle-2.0/common.h>
/*
* Client definitions
*/
drizzle_field_t drizzle_field_read(drizzle_result_st *result, size_t *offset,
size_t *size, size_t *total,
drizzle_return_t *ret_ptr)
{
if (drizzle_state_none(result->con))
{
if (result->field_current == result->column_count)
{
*ret_ptr= DRIZZLE_RETURN_ROW_END;
return NULL;
}
drizzle_state_push(result->con, drizzle_state_field_read);
}
*ret_ptr= drizzle_state_loop(result->con);
if (*ret_ptr == DRIZZLE_RETURN_OK &&
result->options & DRIZZLE_RESULT_ROW_BREAK)
{
*ret_ptr= DRIZZLE_RETURN_ROW_BREAK;
}
*offset= result->field_offset;
*size= result->field_size;
*total= result->field_total;
return result->field;
}
drizzle_field_t drizzle_field_buffer(drizzle_result_st *result, size_t *total,
drizzle_return_t *ret_ptr)
{
size_t offset= 0;
size_t size= 0;
drizzle_return_t unused;
if (ret_ptr == NULL)
{
ret_ptr= &unused;
}
drizzle_field_t field= drizzle_field_read(result, &offset, &size, total, ret_ptr);
if (*ret_ptr != DRIZZLE_RETURN_OK)
{
return NULL;
}
if (field == NULL)
{
*total= 0;
return NULL;
}
if (result->field_buffer == NULL)
{
result->field_buffer= new (std::nothrow) drizzle_field_t_type[(*total) + 1];
if (result->field_buffer == NULL)
{
*ret_ptr= DRIZZLE_RETURN_MEMORY;
*total= 0;
return NULL;
}
}
memcpy(result->field_buffer + offset, field, size);
while ((offset + size) != (*total))
{
field= drizzle_field_read(result, &offset, &size, total, ret_ptr);
if (*ret_ptr != DRIZZLE_RETURN_OK)
{
return NULL;
}
memcpy(result->field_buffer + offset, field, size);
}
field= result->field_buffer;
result->field_buffer= NULL;
field[*total]= 0;
return field;
}
void drizzle_field_free(drizzle_field_t field)
{
delete[] field;
}
/*
* Server definitions
*/
drizzle_return_t drizzle_field_write(drizzle_result_st *result,
const drizzle_field_t field, size_t size,
size_t total)
{
drizzle_return_t ret;
if (drizzle_state_none(result->con))
{
if (result->options & DRIZZLE_RESULT_ROW_BREAK)
{
result->options&= ~DRIZZLE_RESULT_ROW_BREAK;
result->field= field;
result->field_size= size;
}
else
{
result->field= field;
result->field_size= size;
result->field_offset= 0;
result->field_total= total;
}
drizzle_state_push(result->con, drizzle_state_field_write);
}
else if (result->field == NULL)
{
result->field= field;
result->field_size= size;
}
ret= drizzle_state_loop(result->con);
if (ret == DRIZZLE_RETURN_PAUSE)
ret= DRIZZLE_RETURN_OK;
return ret;
}
/*
* Internal state functions.
*/
drizzle_return_t drizzle_state_field_read(drizzle_con_st *con)
{
drizzle_return_t ret;
drizzle_log_debug(con->drizzle, "drizzle_state_field_read");
if (con->buffer_size == 0)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
con->result->field_offset+= con->result->field_size;
if (con->result->field_offset == con->result->field_total)
{
con->result->field_offset= 0;
con->result->field_size= 0;
con->result->field_total= (size_t)drizzle_unpack_length(con, &ret);
if (ret == DRIZZLE_RETURN_NULL_SIZE)
{
con->result->field= NULL;
con->result->field_current++;
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}
else if (ret != DRIZZLE_RETURN_OK)
{
if (ret == DRIZZLE_RETURN_IO_WAIT)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
return ret;
}
drizzle_log_debug(con->drizzle,
"field_offset= %zu, field_size= %zu, field_total= %zu",
con->result->field_offset, con->result->field_size,
con->result->field_total);
if ((size_t)(con->buffer_size) >= con->result->field_total)
con->result->field_size= con->result->field_total;
else
con->result->field_size= con->buffer_size;
}
else
{
if ((con->result->field_offset + con->buffer_size) >=
con->result->field_total)
{
con->result->field_size= (con->result->field_total -
con->result->field_offset);
}
else
con->result->field_size= con->buffer_size;
}
/* This is a special case when a row is larger than the packet size. */
if (con->result->field_size > (size_t)con->packet_size)
{
con->result->field_size= con->packet_size;
if (con->options & DRIZZLE_CON_RAW_PACKET)
con->result->options|= DRIZZLE_RESULT_ROW_BREAK;
else
{
drizzle_state_pop(con);
drizzle_state_push(con, drizzle_state_packet_read);
drizzle_state_push(con, drizzle_state_field_read);
}
}
con->result->field= (char *)con->buffer_ptr;
con->buffer_ptr+= con->result->field_size;
con->buffer_size-= con->result->field_size;
con->packet_size-= con->result->field_size;
drizzle_log_debug(con->drizzle,
"field_offset= %zu, field_size= %zu, field_total= %zu",
con->result->field_offset, con->result->field_size,
con->result->field_total);
if ((con->result->field_offset + con->result->field_size) ==
con->result->field_total)
{
if (con->result->column_buffer != NULL &&
con->result->column_buffer[con->result->field_current].max_size <
con->result->field_total)
{
con->result->column_buffer[con->result->field_current].max_size=
con->result->field_total;
}
con->result->field_current++;
}
if (con->result->field_total == 0 || con->result->field_size > 0 ||
con->packet_size == 0)
{
drizzle_state_pop(con);
}
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_field_write(drizzle_con_st *con)
{
uint8_t *start= con->buffer_ptr + con->buffer_size;
uint8_t *ptr;
size_t free_size;
drizzle_result_st *result= con->result;
drizzle_log_debug(con->drizzle, "drizzle_state_field_write");
if (result->field == NULL && result->field_total != 0)
return DRIZZLE_RETURN_PAUSE;
free_size= (size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer);
ptr= start;
if (result->field_offset == 0)
{
/* Make sure we can fit the max length and 1 byte of data in (9 + 1). */
if (free_size < 10)
{
drizzle_state_push(con, drizzle_state_write);
return DRIZZLE_RETURN_OK;
}
if (result->field == NULL)
{
ptr[0]= 251;
ptr++;
}
else if (result->field_total == 0)
{
ptr[0]= 0;
ptr++;
}
else
ptr= drizzle_pack_length(result->field_total, ptr);
free_size-= (size_t)(ptr - start);
con->buffer_size+= (size_t)(ptr - start);
con->packet_size-= (size_t)(ptr - start);
}
else if (result->field_size > DRIZZLE_BUFFER_COPY_THRESHOLD)
{
/* Flush the internal buffer first. */
if (con->buffer_size != 0)
{
drizzle_state_push(con, drizzle_state_write);
return DRIZZLE_RETURN_OK;
}
/* We do this to write directly from the field buffer to avoid memcpy(). */
con->buffer_ptr= (uint8_t *)result->field;
con->buffer_size= result->field_size;
con->packet_size-= result->field_size;
result->field_offset+= result->field_size;
result->field= NULL;
if (result->field_offset == result->field_total)
drizzle_state_pop(con);
else if (con->packet_size == 0)
{
con->result->options|= DRIZZLE_RESULT_ROW_BREAK;
drizzle_state_pop(con);
}
drizzle_state_push(con, drizzle_state_write);
return DRIZZLE_RETURN_OK;
}
if (result->field_size == 0)
drizzle_state_pop(con);
else
{
if (result->field_size < free_size)
free_size= result->field_size;
memcpy(ptr, result->field, free_size);
result->field_offset+= free_size;
con->buffer_size+= free_size;
con->packet_size-= free_size;
if (result->field_offset == result->field_total)
{
result->field= NULL;
drizzle_state_pop(con);
}
else
{
if (con->packet_size == 0)
{
con->result->options|= DRIZZLE_RESULT_ROW_BREAK;
drizzle_state_pop(con);
}
if (result->field_size == free_size)
result->field= NULL;
else
{
result->field+= free_size;
result->field_size-= free_size;
drizzle_state_push(con, drizzle_state_write);
}
}
}
return DRIZZLE_RETURN_OK;
}

612
utils/mysqlcl_idb/handshake.cc
View File

@ -1,612 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Handshake Definitions
*/
#include <libdrizzle-2.0/common.h>
/*
* Client Definitions
*/
drizzle_return_t drizzle_handshake_server_read(drizzle_con_st *con)
{
if (drizzle_state_none(con))
{
drizzle_state_push(con, drizzle_state_handshake_server_read);
drizzle_state_push(con, drizzle_state_packet_read);
}
return drizzle_state_loop(con);
}
drizzle_return_t drizzle_handshake_client_write(drizzle_con_st *con)
{
if (drizzle_state_none(con))
{
drizzle_state_push(con, drizzle_state_write);
drizzle_state_push(con, drizzle_state_handshake_client_write);
}
return drizzle_state_loop(con);
}
/*
* Server Definitions
*/
drizzle_return_t drizzle_handshake_server_write(drizzle_con_st *con)
{
if (drizzle_state_none(con))
{
drizzle_state_push(con, drizzle_state_write);
drizzle_state_push(con, drizzle_state_handshake_server_write);
}
return drizzle_state_loop(con);
}
drizzle_return_t drizzle_handshake_client_read(drizzle_con_st *con)
{
if (drizzle_state_none(con))
{
drizzle_state_push(con, drizzle_state_handshake_client_read);
drizzle_state_push(con, drizzle_state_packet_read);
}
return drizzle_state_loop(con);
}
/*
* State Definitions
*/
drizzle_return_t drizzle_state_handshake_server_read(drizzle_con_st *con)
{
uint8_t *ptr;
int extra_length;
unsigned char* packet_end;
drizzle_log_debug(con->drizzle, "drizzle_state_handshake_server_read");
/* Assume the entire handshake packet will fit in the buffer. */
if (con->buffer_size < con->packet_size)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
if (con->packet_size < 46)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
"bad packet size:>=46:%zu", con->packet_size);
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
packet_end= con->buffer_ptr + con->packet_size;
con->protocol_version= con->buffer_ptr[0];
con->buffer_ptr++;
if (con->protocol_version != 10)
{
/* This is a special case where the server determines that authentication
will be impossible and denies any attempt right away. */
if (con->protocol_version == 255)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
"%.*s", (int32_t)con->packet_size - 3,
con->buffer_ptr + 2);
return DRIZZLE_RETURN_AUTH_FAILED;
}
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
"protocol version not supported:%d",
con->protocol_version);
return DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED;
}
/* Look for null-terminated server version string. */
ptr= (uint8_t *)memchr(con->buffer_ptr, 0, con->buffer_size - 1);
if (ptr == NULL)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
"server version string not found");
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
if (con->packet_size < (46 + (size_t)(ptr - con->buffer_ptr)))
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
"bad packet size:%zu:%zu",
(46 + (size_t)(ptr - con->buffer_ptr)), con->packet_size);
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
strncpy(con->server_version, (char *)con->buffer_ptr,
DRIZZLE_MAX_SERVER_VERSION_SIZE);
con->server_version[DRIZZLE_MAX_SERVER_VERSION_SIZE - 1]= 0;
con->buffer_ptr+= ((ptr - con->buffer_ptr) + 1);
con->thread_id= (uint32_t)drizzle_get_byte4(con->buffer_ptr);
con->buffer_ptr+= 4;
con->scramble= con->scramble_buffer;
memcpy(con->scramble, con->buffer_ptr, 8);
/* Skip scramble and filler. */
con->buffer_ptr+= 9;
/* Even though drizzle_capabilities is more than 2 bytes, the protocol only
allows for 2. This means some capabilities are not possible during this
handshake step. The options beyond 2 bytes are for client response only. */
con->capabilities= (drizzle_capabilities_t)drizzle_get_byte2(con->buffer_ptr);
con->buffer_ptr+= 2;
if (con->options & DRIZZLE_CON_MYSQL &&
!(con->capabilities & DRIZZLE_CAPABILITIES_PROTOCOL_41))
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
"protocol version not supported, must be MySQL 4.1+");
return DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED;
}
con->charset= con->buffer_ptr[0];
con->buffer_ptr+= 1;
con->status= (drizzle_con_status_t)drizzle_get_byte2(con->buffer_ptr);
/* Skip status and filler. */
con->buffer_ptr+= 15;
memcpy(con->scramble + 8, con->buffer_ptr, 12);
con->buffer_ptr+= 13;
/* MySQL 5.5 adds "mysql_native_password" after the server greeting. */
extra_length= packet_end - con->buffer_ptr;
assert(extra_length >= 0);
if (extra_length > DRIZZLE_MAX_SERVER_EXTRA_SIZE - 1)
extra_length= DRIZZLE_MAX_SERVER_EXTRA_SIZE - 1;
memcpy(con->server_extra, (char *)con->buffer_ptr, extra_length);
con->server_extra[extra_length]= 0;
con->buffer_size-= con->packet_size;
if (con->buffer_size != 0)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
"unexpected data after packet:%zu", con->buffer_size);
return DRIZZLE_RETURN_UNEXPECTED_DATA;
}
con->buffer_ptr= con->buffer;
drizzle_state_pop(con);
if (!(con->options & DRIZZLE_CON_RAW_PACKET))
{
drizzle_state_push(con, drizzle_state_handshake_result_read);
drizzle_state_push(con, drizzle_state_packet_read);
drizzle_state_push(con, drizzle_state_write);
drizzle_state_push(con, drizzle_state_handshake_client_write);
}
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_handshake_server_write(drizzle_con_st *con)
{
uint8_t *ptr;
drizzle_log_debug(con->drizzle, "drizzle_state_handshake_server_write");
/* Calculate max packet size. */
con->packet_size= 1 /* Protocol version */
+ strlen(con->server_version) + 1
+ 4 /* Thread ID */
+ 8 /* Scramble */
+ 1 /* NULL */
+ 2 /* Capabilities */
+ 1 /* Language */
+ 2 /* Status */
+ 13 /* Unused */
+ 12 /* Scramble */
+ 1; /* NULL */
/* Assume the entire handshake packet will fit in the buffer. */
if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_write",
"buffer too small:%zu", con->packet_size + 4);
return DRIZZLE_RETURN_INTERNAL_ERROR;
}
ptr= con->buffer_ptr;
/* Store packet size and packet number first. */
drizzle_set_byte3(ptr, con->packet_size);
ptr[3]= 0;
con->packet_number= 1;
ptr+= 4;
ptr[0]= con->protocol_version;
ptr++;
memcpy(ptr, con->server_version, strlen(con->server_version));
ptr+= strlen(con->server_version);
ptr[0]= 0;
ptr++;
drizzle_set_byte4(ptr, con->thread_id);
ptr+= 4;
if (con->scramble == NULL)
memset(ptr, 0, 8);
else
memcpy(ptr, con->scramble, 8);
ptr+= 8;
ptr[0]= 0;
ptr++;
if (con->options & DRIZZLE_CON_MYSQL)
con->capabilities|= DRIZZLE_CAPABILITIES_PROTOCOL_41;
/* We can only send two bytes worth, this is a protocol limitation. */
drizzle_set_byte2(ptr, con->capabilities);
ptr+= 2;
ptr[0]= con->charset;
ptr++;
drizzle_set_byte2(ptr, con->status);
ptr+= 2;
memset(ptr, 0, 13);
ptr+= 13;
if (con->scramble == NULL)
memset(ptr, 0, 12);
else
memcpy(ptr, con->scramble + 8, 12);
ptr+= 12;
ptr[0]= 0;
ptr++;
con->buffer_size+= (4 + con->packet_size);
/* Make sure we packed it correctly. */
if ((size_t)(ptr - con->buffer_ptr) != (4 + con->packet_size))
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_write",
"error packing server handshake:%zu:%zu",
(size_t)(ptr - con->buffer_ptr), 4 + con->packet_size);
return DRIZZLE_RETURN_INTERNAL_ERROR;
}
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_handshake_client_read(drizzle_con_st *con)
{
size_t real_size;
uint8_t *ptr;
uint8_t scramble_size;
drizzle_log_debug(con->drizzle, "drizzle_state_handshake_client_read");
/* Assume the entire handshake packet will fit in the buffer. */
if (con->buffer_size < con->packet_size)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
/* This is the minimum packet size. */
if (con->packet_size < 34)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"bad packet size:>=34:%zu", con->packet_size);
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
real_size= 34;
con->capabilities= drizzle_get_byte4(con->buffer_ptr);
con->buffer_ptr+= 4;
if (con->options & DRIZZLE_CON_MYSQL &&
!(con->capabilities & DRIZZLE_CAPABILITIES_PROTOCOL_41))
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"protocol version not supported, must be MySQL 4.1+");
return DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED;
}
con->max_packet_size= (uint32_t)drizzle_get_byte4(con->buffer_ptr);
con->buffer_ptr+= 4;
con->charset= con->buffer_ptr[0];
con->buffer_ptr+= 1;
/* Skip unused. */
con->buffer_ptr+= 23;
/* Look for null-terminated user string. */
ptr= (uint8_t *)memchr(con->buffer_ptr, 0, con->buffer_size - 32);
if (ptr == NULL)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"user string not found");
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
if (con->buffer_ptr == ptr)
{
con->user[0]= 0;
con->buffer_ptr++;
}
else
{
real_size+= (size_t)(ptr - con->buffer_ptr);
if (con->packet_size < real_size)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"bad packet size:>=%zu:%zu", real_size,
con->packet_size);
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
strncpy(con->user, (char *)con->buffer_ptr, DRIZZLE_MAX_USER_SIZE);
con->user[DRIZZLE_MAX_USER_SIZE - 1]= 0;
con->buffer_ptr+= ((ptr - con->buffer_ptr) + 1);
}
scramble_size= con->buffer_ptr[0];
con->buffer_ptr+= 1;
if (scramble_size == 0)
{
con->scramble= NULL;
}
else
{
if (scramble_size != DRIZZLE_MAX_SCRAMBLE_SIZE)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"wrong scramble size");
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
real_size+= scramble_size;
con->scramble= con->scramble_buffer;
memcpy(con->scramble, con->buffer_ptr, DRIZZLE_MAX_SCRAMBLE_SIZE);
con->buffer_ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
}
/* Look for null-terminated schema string. */
if ((34 + strlen(con->user) +scramble_size) == con->packet_size)
{
con->schema[0]= 0;
}
else
{
ptr= (uint8_t *)memchr(con->buffer_ptr, 0, con->buffer_size -
(34 + strlen(con->user) + scramble_size));
if (ptr == NULL)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"schema string not found");
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
real_size+= ((size_t)(ptr - con->buffer_ptr) + 1);
if (con->packet_size != real_size)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"bad packet size:%zu:%zu", real_size, con->packet_size);
return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
}
if (con->buffer_ptr == ptr)
{
con->schema[0]= 0;
con->buffer_ptr++;
}
else
{
strncpy(con->schema, (char *)con->buffer_ptr, DRIZZLE_MAX_DB_SIZE);
con->schema[DRIZZLE_MAX_DB_SIZE - 1]= 0;
con->buffer_ptr+= ((ptr - con->buffer_ptr) + 1);
}
}
con->buffer_size-= con->packet_size;
if (con->buffer_size != 0)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
"unexpected data after packet:%zu", con->buffer_size);
return DRIZZLE_RETURN_UNEXPECTED_DATA;
}
con->buffer_ptr= con->buffer;
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_handshake_client_write(drizzle_con_st *con)
{
uint8_t *ptr;
int capabilities;
drizzle_log_debug(con->drizzle, "drizzle_state_handshake_client_write");
/* Calculate max packet size. */
con->packet_size= 4 /* Capabilities */
+ 4 /* Max packet size */
+ 1 /* Charset */
+ 23 /* Unused */
+ strlen(con->user) + 1
+ 1 /* Scramble size */
+ DRIZZLE_MAX_SCRAMBLE_SIZE
+ strlen(con->schema) + 1;
/* Assume the entire handshake packet will fit in the buffer. */
if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_write",
"buffer too small:%zu", con->packet_size + 4);
return DRIZZLE_RETURN_INTERNAL_ERROR;
}
ptr= con->buffer_ptr;
/* Store packet size at the end since it may change. */
ptr[3]= con->packet_number;
con->packet_number++;
ptr+= 4;
if (con->options & DRIZZLE_CON_MYSQL)
{
con->capabilities|= DRIZZLE_CAPABILITIES_PROTOCOL_41;
}
capabilities= con->capabilities & DRIZZLE_CAPABILITIES_CLIENT;
if (!(con->options & DRIZZLE_CON_FOUND_ROWS))
capabilities&= ~DRIZZLE_CAPABILITIES_FOUND_ROWS;
if (con->options & DRIZZLE_CON_INTERACTIVE)
{
capabilities|= DRIZZLE_CAPABILITIES_INTERACTIVE;
}
if (con->options & DRIZZLE_CON_MULTI_STATEMENTS)
{
capabilities|= DRIZZLE_CAPABILITIES_MULTI_STATEMENTS;
}
if (con->options & DRIZZLE_CON_AUTH_PLUGIN)
{
capabilities|= DRIZZLE_CAPABILITIES_PLUGIN_AUTH;
}
capabilities&= ~(DRIZZLE_CAPABILITIES_COMPRESS | DRIZZLE_CAPABILITIES_SSL);
if (con->schema[0] == 0)
{
capabilities&= ~DRIZZLE_CAPABILITIES_CONNECT_WITH_DB;
}
drizzle_set_byte4(ptr, capabilities);
ptr+= 4;
drizzle_set_byte4(ptr, con->max_packet_size);
ptr+= 4;
ptr[0]= con->charset;
ptr++;
memset(ptr, 0, 23);
ptr+= 23;
drizzle_return_t ret;
ptr= drizzle_pack_auth(con, ptr, &ret);
if (ret != DRIZZLE_RETURN_OK)
{
return ret;
}
con->buffer_size+= (4 + con->packet_size);
/* Make sure we packed it correctly. */
if ((size_t)(ptr - con->buffer_ptr) != (4 + con->packet_size))
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_write",
"error packing client handshake:%zu:%zu",
(size_t)(ptr - con->buffer_ptr), 4 + con->packet_size);
return DRIZZLE_RETURN_INTERNAL_ERROR;
}
/* Store packet size now. */
drizzle_set_byte3(con->buffer_ptr, con->packet_size);
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_handshake_result_read(drizzle_con_st *con)
{
drizzle_result_st *result;
drizzle_log_debug(con->drizzle, "drizzle_state_handshake_result_read");
if ((result= drizzle_result_create(con)) == NULL)
{
return DRIZZLE_RETURN_MEMORY;
}
con->result= result;
drizzle_return_t ret= drizzle_state_result_read(con);
if (drizzle_state_none(con))
{
if (ret == DRIZZLE_RETURN_OK)
{
if (drizzle_result_eof(result))
{
drizzle_set_error(con->drizzle, "drizzle_state_handshake_result_read",
"old insecure authentication mechanism not supported");
ret= DRIZZLE_RETURN_AUTH_FAILED;
}
else
{
con->options|= DRIZZLE_CON_READY;
}
}
}
drizzle_result_free(result);
if (ret == DRIZZLE_RETURN_ERROR_CODE)
{
return DRIZZLE_RETURN_HANDSHAKE_FAILED;
}
return ret;
}

176
utils/mysqlcl_idb/libdrizzle-2.0/column.h
View File

@ -1,176 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Column Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_column Column Declarations
* @ingroup drizzle_client_interface
* @ingroup drizzle_server_interface
*
* These functions are used to get detailed column information. This information
* is usually sent as the first part of a result set. There are multiple ways
* for column information to be buffered depending on the functions being used.
* @{
*/
/**
* Initialize a column structure.
*/
DRIZZLE_API
drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
drizzle_column_st *column);
/**
* Free a column structure.
*/
DRIZZLE_API
void drizzle_column_free(drizzle_column_st *column);
/**
* Get the drizzle_result_st struct that the column belongs to.
*/
DRIZZLE_API
drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column);
/**
* Get catalog name for a column.
*/
DRIZZLE_API
const char *drizzle_column_catalog(drizzle_column_st *column);
/**
* Get schema name for a column.
*/
DRIZZLE_API
const char *drizzle_column_shema(drizzle_column_st *column);
DRIZZLE_API
const char *drizzle_column_db(drizzle_column_st *column);
/**
* Get table name for a column.
*/
DRIZZLE_API
const char *drizzle_column_table(drizzle_column_st *column);
/**
* Get original table name for a column.
*/
DRIZZLE_API
const char *drizzle_column_orig_table(drizzle_column_st *column);
/**
* Get column name for a column.
*/
DRIZZLE_API
const char *drizzle_column_name(drizzle_column_st *column);
/**
* Get original column name for a column.
*/
DRIZZLE_API
const char *drizzle_column_orig_name(drizzle_column_st *column);
/**
* Get charset for a column.
*/
DRIZZLE_API
drizzle_charset_t drizzle_column_charset(drizzle_column_st *column);
/**
* Get size of a column.
*/
DRIZZLE_API
uint32_t drizzle_column_size(drizzle_column_st *column);
/**
* Get max size of a column.
*/
DRIZZLE_API
size_t drizzle_column_max_size(drizzle_column_st *column);
/**
* Set max size of a column.
*/
DRIZZLE_API
void drizzle_column_set_max_size(drizzle_column_st *column, size_t size);
/**
* Get the type of a column.
*/
DRIZZLE_API
drizzle_column_type_t drizzle_column_type(drizzle_column_st *column);
/**
* Get the Drizzle type of a column.
*/
DRIZZLE_API
drizzle_column_type_drizzle_t drizzle_column_type_drizzle(drizzle_column_st *column);
/**
* Get flags for a column.
*/
DRIZZLE_API
int drizzle_column_flags(drizzle_column_st *column);
/**
* Get the number of decimals for numeric columns.
*/
DRIZZLE_API
uint8_t drizzle_column_decimals(drizzle_column_st *column);
/**
* Get default value for a column.
*/
DRIZZLE_API
const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
size_t *size);
/** @} */
#ifdef __cplusplus
}
#endif

125
utils/mysqlcl_idb/libdrizzle-2.0/column_client.h
View File

@ -1,125 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Column Declarations for Clients
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_column_client Column Declarations for Clients
* @ingroup drizzle_client_interface
*
* These functions are used to get detailed column information. This information
* is usually sent as the first part of a result set. There are both buffered
* and unbuffered functions provided.
* @{
*/
/**
* Skip a column in result.
*/
DRIZZLE_API
drizzle_return_t drizzle_column_skip(drizzle_result_st *result);
/**
* Skip all columns in a result.
*/
DRIZZLE_API
drizzle_return_t drizzle_column_skip_all(drizzle_result_st *result);
/**
* Read column information.
*
* @param[in,out] result pointer to the structure to read from.
* @param[out] column pointer to the structure to contain the information.
* @param[out] ret_ptr Standard libdrizzle return value.
* @return column if there is valid data, NULL if there are no more columns.
*/
DRIZZLE_API
drizzle_column_st *drizzle_column_read(drizzle_result_st *result,
drizzle_column_st *column,
drizzle_return_t *ret_ptr);
/**
* Buffer all columns in result structure.
*/
DRIZZLE_API
drizzle_return_t drizzle_column_buffer(drizzle_result_st *result);
/**
* Get next buffered column from a result structure.
*/
DRIZZLE_API
drizzle_column_st *drizzle_column_next(drizzle_result_st *result);
/**
* Get previous buffered column from a result structure.
*/
DRIZZLE_API
drizzle_column_st *drizzle_column_prev(drizzle_result_st *result);
/**
* Seek to the given buffered column in a result structure.
*/
DRIZZLE_API
void drizzle_column_seek(drizzle_result_st *result, uint16_t column);
/**
* Get the given buffered column from a result structure.
*/
DRIZZLE_API
drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
uint16_t column);
/**
* Get current column number in a buffered or unbuffered result.
*/
DRIZZLE_API
uint16_t drizzle_column_current(drizzle_result_st *result);
/** @} */
#ifdef __cplusplus
}
#endif

149
utils/mysqlcl_idb/libdrizzle-2.0/column_server.h
View File

@ -1,149 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Column Declarations for Servers
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_column_server Column Declarations for Servers
* @ingroup drizzle_server_interface
*
* These functions allow you to send column information over a connection.
* @{
*/
/**
* Write column information.
*/
DRIZZLE_API
drizzle_return_t drizzle_column_write(drizzle_result_st *result,
drizzle_column_st *column);
/**
* Set catalog name for a column.
*/
DRIZZLE_API
void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog);
/**
* Set database name for a column.
*/
DRIZZLE_API
void drizzle_column_set_db(drizzle_column_st *column, const char *db);
DRIZZLE_API
void drizzle_column_set_schema(drizzle_column_st *column, const char *schema);
/**
* Set table name for a column.
*/
DRIZZLE_API
void drizzle_column_set_table(drizzle_column_st *column, const char *table);
/**
* Set original table name for a column.
*/
DRIZZLE_API
void drizzle_column_set_orig_table(drizzle_column_st *column,
const char *orig_table);
/**
* Set column name for a column.
*/
DRIZZLE_API
void drizzle_column_set_name(drizzle_column_st *column, const char *name);
/**
* Set original column name for a column.
*/
DRIZZLE_API
void drizzle_column_set_orig_name(drizzle_column_st *column,
const char *orig_name);
/**
* Set charset for a column.
*/
DRIZZLE_API
void drizzle_column_set_charset(drizzle_column_st *column,
drizzle_charset_t charset);
/**
* Set size of a column.
*/
DRIZZLE_API
void drizzle_column_set_size(drizzle_column_st *column, uint32_t size);
/**
* Set the type of a column.
*/
DRIZZLE_API
void drizzle_column_set_type(drizzle_column_st *column,
drizzle_column_type_t type);
/**
* Set flags for a column.
*/
DRIZZLE_API
void drizzle_column_set_flags(drizzle_column_st *column,
int flags);
/**
* Set the number of decimals for numeric columns.
*/
DRIZZLE_API
void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals);
/**
* Set default value for a column.
*/
DRIZZLE_API
void drizzle_column_set_default_value(drizzle_column_st *column,
const uint8_t *default_value,
size_t size);
/** @} */
#ifdef __cplusplus
}
#endif

102
utils/mysqlcl_idb/libdrizzle-2.0/command.h
View File

@ -1,102 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2011 Brian Aker (brian@tangent.org)
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @ingroup drizzle_command
* Commands for drizzle_command functions.
*/
enum drizzle_command_t
{
DRIZZLE_COMMAND_SLEEP, /* Not used currently. */
DRIZZLE_COMMAND_QUIT,
DRIZZLE_COMMAND_INIT_DB,
DRIZZLE_COMMAND_QUERY,
DRIZZLE_COMMAND_FIELD_LIST, /* Deprecated. */
DRIZZLE_COMMAND_CREATE_DB, /* Deprecated. */
DRIZZLE_COMMAND_DROP_DB, /* Deprecated. */
DRIZZLE_COMMAND_REFRESH,
DRIZZLE_COMMAND_SHUTDOWN,
DRIZZLE_COMMAND_STATISTICS,
DRIZZLE_COMMAND_PROCESS_INFO, /* Deprecated. */
DRIZZLE_COMMAND_CONNECT, /* Not used currently. */
DRIZZLE_COMMAND_PROCESS_KILL, /* Deprecated. */
DRIZZLE_COMMAND_DEBUG,
DRIZZLE_COMMAND_PING,
DRIZZLE_COMMAND_TIME, /* Not used currently. */
DRIZZLE_COMMAND_DELAYED_INSERT, /* Not used currently. */
DRIZZLE_COMMAND_CHANGE_USER,
DRIZZLE_COMMAND_BINLOG_DUMP, /* Not used currently. */
DRIZZLE_COMMAND_TABLE_DUMP, /* Not used currently. */
DRIZZLE_COMMAND_CONNECT_OUT, /* Not used currently. */
DRIZZLE_COMMAND_REGISTER_SLAVE, /* Not used currently. */
DRIZZLE_COMMAND_STMT_PREPARE, /* Not used currently. */
DRIZZLE_COMMAND_STMT_EXECUTE, /* Not used currently. */
DRIZZLE_COMMAND_STMT_SEND_LONG_DATA, /* Not used currently. */
DRIZZLE_COMMAND_STMT_CLOSE, /* Not used currently. */
DRIZZLE_COMMAND_STMT_RESET, /* Not used currently. */
DRIZZLE_COMMAND_SET_OPTION, /* Not used currently. */
DRIZZLE_COMMAND_STMT_FETCH, /* Not used currently. */
DRIZZLE_COMMAND_DAEMON, /* Not used currently. */
DRIZZLE_COMMAND_END /* Not used currently. */
};
#ifndef __cplusplus
typedef enum drizzle_command_t drizzle_command_t;
#endif
/**
* @ingroup drizzle_command
* Commands for the Drizzle protocol functions.
*/
enum drizzle_command_drizzle_t
{
DRIZZLE_COMMAND_DRIZZLE_SLEEP,
DRIZZLE_COMMAND_DRIZZLE_QUIT,
DRIZZLE_COMMAND_DRIZZLE_INIT_DB,
DRIZZLE_COMMAND_DRIZZLE_QUERY,
DRIZZLE_COMMAND_DRIZZLE_SHUTDOWN,
DRIZZLE_COMMAND_DRIZZLE_CONNECT,
DRIZZLE_COMMAND_DRIZZLE_PING,
DRIZZLE_COMMAND_DRIZZLE_KILL,
DRIZZLE_COMMAND_DRIZZLE_END
};
#ifndef __cplusplus
typedef enum drizzle_command_drizzle_t drizzle_command_drizzle_t;
#endif

61
utils/mysqlcl_idb/libdrizzle-2.0/command_client.h
View File

@ -1,61 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Command Declarations for Clients
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_command_client Command Declarations for Clients
* @ingroup drizzle_client_interface
*
* These functions are used to issue commands on a connection. Normal SQL
* queries are issued using the drizzle_query* functions defined in query.h.
* @{
*/
/** @} */
#ifdef __cplusplus
}
#endif

60
utils/mysqlcl_idb/libdrizzle-2.0/command_server.h
View File

@ -1,60 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Command Declarations for Servers
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_command_server Command Declarations for Servers
* @ingroup drizzle_server_interface
*
* These functions allow you to read comands on a connection.
* @{
*/
/** @} */
#ifdef __cplusplus
}
#endif

94
utils/mysqlcl_idb/libdrizzle-2.0/common.h
View File

@ -1,94 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief System Include Files
*/
#pragma once
#include <config.h>
#include <libdrizzle-2.0/drizzle_client.h>
#include <libdrizzle-2.0/drizzle_server.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#ifndef _WIN32
# include <netinet/tcp.h>
# include <sys/uio.h>
# include <unistd.h>
#endif
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <libdrizzle-2.0/drizzle_local.h>
#include <libdrizzle-2.0/conn_local.h>
#include <libdrizzle-2.0/pack.h>
#include <libdrizzle-2.0/state.h>
#include <libdrizzle-2.0/sha1.h>
#ifdef _MSC_VER
#define random() rand()
#define srandom(a) srand(a)
#define get_socket_errno() WSAGetLastError()
#else
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define closesocket(a) close(a)
#define get_socket_errno() errno
#endif
#ifndef PACKAGE_BUGREPORT
#define PACKAGE_BUGREPORT "drizzle@drizzle.org"
#endif
#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION "2.0"
#endif
#ifdef __cplusplus
# include <limits>
# ifndef UINT32_MAX
const unsigned int UINT32_MAX=std::numeric_limits<unsigned int>::max();
# endif
#endif

436
utils/mysqlcl_idb/libdrizzle-2.0/conn.h
View File

@ -1,436 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Connection Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_con Connection Declarations
* @ingroup drizzle_client_interface
* @ingroup drizzle_server_interface
* @{
*/
/**
* Get file descriptor for connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return File descriptor of connection, or -1 if not active.
*/
DRIZZLE_API
int drizzle_con_fd(const drizzle_con_st *con);
/**
* Use given file descriptor for connction.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] fd File descriptor for connection.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_con_set_fd(drizzle_con_st *con, int fd);
/**
* Close a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
*/
DRIZZLE_API
void drizzle_con_close(drizzle_con_st *con);
/**
* Set events to be watched for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] events Bitfield of poll() events to watch.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_con_set_events(drizzle_con_st *con, short events);
/**
* Set events that are ready for a connection. This is used with the external
* event callbacks. See drizzle_set_event_watch_fn().
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] revents Bitfield of poll() events that were detected.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_con_set_revents(drizzle_con_st *con, short revents);
/**
* Get the drizzle_st struct that the connection belongs to.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Drizzle object that this connection is part of.
*/
DRIZZLE_API
drizzle_st *drizzle_con_drizzle(const drizzle_con_st *con);
/**
* Return an error string for last error encountered.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Pointer to static buffer in library that holds an error string.
*/
DRIZZLE_API
const char *drizzle_con_error(const drizzle_con_st *con);
/**
* Value of errno in the case of a DRIZZLE_RETURN_ERRNO return value.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return An errno value as defined in your system errno.h file.
*/
DRIZZLE_API
int drizzle_con_errno(const drizzle_con_st *con);
/**
* Get server defined error code for the last result read.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return An error code given back in the server response.
*/
DRIZZLE_API
uint16_t drizzle_con_error_code(const drizzle_con_st *con);
/**
* Get SQL state code for the last result read.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return A SQLSTATE code given back in the server response.
*/
DRIZZLE_API
const char *drizzle_con_sqlstate(const drizzle_con_st *con);
/**
* Get options for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Options set for the connection structure.
*/
DRIZZLE_API
int drizzle_con_options(const drizzle_con_st *con);
/**
* Set options for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] options Available options for connection structure to set.
*/
DRIZZLE_API
void drizzle_con_set_options(drizzle_con_st *con,
int options);
/**
* Add options for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] options Available options for connection structure to set.
*/
DRIZZLE_API
void drizzle_con_add_options(drizzle_con_st *con,
int options);
/**
* Remove options for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] options Available options for connection structure to remove.
*/
DRIZZLE_API
void drizzle_con_remove_options(drizzle_con_st *con,
int options);
/**
* Get TCP host for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Host this connection is configured for, or NULL if not set.
*/
DRIZZLE_API
const char *drizzle_con_host(const drizzle_con_st *con);
/**
* Get TCP port for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Port this connection is configured for, 0 if not set.
*/
DRIZZLE_API
in_port_t drizzle_con_port(const drizzle_con_st *con);
/**
* Set TCP host and port for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] host Host to use for this connection, NULL for default value.
* @param[in] port Port to use for this connection, 0 for default value.
*/
DRIZZLE_API
void drizzle_con_set_tcp(drizzle_con_st *con, const char *host, in_port_t port);
/**
* Get unix domain socket for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Unix domain socket set for this connection, NULL if not set.
*/
DRIZZLE_API
const char *drizzle_con_uds(const drizzle_con_st *con);
/**
* Set unix domain socket for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] uds Unix domain socket to use for this connection, NULL for
* defailt value.
*/
DRIZZLE_API
void drizzle_con_set_uds(drizzle_con_st *con, const char *uds);
/**
* Get username for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return User associated with this connection.
*/
DRIZZLE_API
const char *drizzle_con_user(const drizzle_con_st *con);
/**
* Get password for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Password associated with this connection.
*/
DRIZZLE_API
const char *drizzle_con_password(const drizzle_con_st *con);
/**
* Set username and password for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] user Username to use for this connection.
* @param[in] password Password to use for this connection.
*/
DRIZZLE_API
void drizzle_con_set_auth(drizzle_con_st *con, const char *user,
const char *password);
/**
* Get database for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Database associated with this connection.
*/
DRIZZLE_API
const char *drizzle_con_schema(const drizzle_con_st *con);
DRIZZLE_API
const char *drizzle_con_db(const drizzle_con_st *con);
/**
* Set database for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] schema Database to use with this connection.
*/
DRIZZLE_API
void drizzle_con_set_schema(drizzle_con_st *con, const char *schema);
DRIZZLE_API
void drizzle_con_set_db(drizzle_con_st *con, const char *schema);
/**
* Get application context pointer for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Application context with this connection.
*/
DRIZZLE_API
void *drizzle_con_context(const drizzle_con_st *con);
/**
* Set application context pointer for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] context Application context to use with this connection.
*/
DRIZZLE_API
void drizzle_con_set_context(drizzle_con_st *con, void *context);
/**
* Set callback function when the context pointer should be freed.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] function Function to call to clean up connection context.
*/
DRIZZLE_API
void drizzle_con_set_context_free_fn(drizzle_con_st *con,
drizzle_con_context_free_fn *function);
/**
* Get protocol version for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Protocol version for connection.
*/
DRIZZLE_API
uint8_t drizzle_con_protocol_version(const drizzle_con_st *con);
/**
* Get server version string for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Server version string for connection.
*/
DRIZZLE_API
const char *drizzle_con_server_version(const drizzle_con_st *con);
/**
* Get server version number for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Server version number for connection.
*/
DRIZZLE_API
uint32_t drizzle_con_server_version_number(const drizzle_con_st *con);
/**
* Get thread ID for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Thread ID for connection.
*/
DRIZZLE_API
uint32_t drizzle_con_thread_id(const drizzle_con_st *con);
/**
* Get scramble buffer for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Scramble buffer for connection.
*/
DRIZZLE_API
const uint8_t *drizzle_con_scramble(const drizzle_con_st *con);
/**
* Get capabilities for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Capabilities for connection.
*/
DRIZZLE_API
int drizzle_con_capabilities(const drizzle_con_st *con);
/**
* Get character set for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Character set for connection.
*/
DRIZZLE_API
drizzle_charset_t drizzle_con_charset(const drizzle_con_st *con);
/**
* Get status for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Status for connection.
*/
DRIZZLE_API
drizzle_con_status_t drizzle_con_status(const drizzle_con_st *con);
/**
* Get max packet size for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Max packet size for connection.
*/
DRIZZLE_API
uint32_t drizzle_con_max_packet_size(const drizzle_con_st *con);
/** @} */
#ifdef __cplusplus
}
#endif

192
utils/mysqlcl_idb/libdrizzle-2.0/conn_client.h
View File

@ -1,192 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Connection Declarations for Clients
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_con_client Connection Declarations for Clients
* @ingroup drizzle_client_interface
* @{
*/
/**
* Connect to server.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_con_connect(drizzle_con_st *con);
/**
* Send quit command to server for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] result Caller allocated structure, or NULL to allocate one.
* @param[out] ret_ptr Standard drizzle return value.
* @return On success, a pointer to the (possibly allocated) structure. On
* failure this will be NULL.
*/
DRIZZLE_API
drizzle_result_st *drizzle_con_quit(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_return_t *ret_ptr);
/**
* @todo Remove this with next major API change.
*/
DRIZZLE_API
drizzle_result_st *drizzle_quit(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_return_t *ret_ptr);
/**
* Select a new default database for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] result Caller allocated structure, or NULL to allocate one.
* @param[in] db Default database to select.
* @param[out] ret_ptr Standard drizzle return value.
* @return On success, a pointer to the (possibly allocated) structure. On
* failure this will be NULL.
*/
DRIZZLE_API
drizzle_result_st *drizzle_con_select_db(drizzle_con_st *con,
drizzle_result_st *result,
const char *db,
drizzle_return_t *ret_ptr);
/**
* @todo Remove this with next major API change.
*/
DRIZZLE_API
drizzle_result_st *drizzle_select_db(drizzle_con_st *con,
drizzle_result_st *result,
const char *db,
drizzle_return_t *ret_ptr);
/**
* Send a shutdown message to the server.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] result Caller allocated structure, or NULL to allocate one.
* @param[out] ret_ptr Standard drizzle return value.
* @return On success, a pointer to the (possibly allocated) structure. On
* failure this will be NULL.
*/
DRIZZLE_API
drizzle_result_st *drizzle_con_shutdown(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_return_t *ret_ptr);
DRIZZLE_API
drizzle_result_st *drizzle_kill(drizzle_con_st *con,
drizzle_result_st *result,
uint32_t query_id,
drizzle_return_t *ret_ptr);
/**
* @todo Remove this with next major API change.
*/
#define DRIZZLE_SHUTDOWN_DEFAULT 0
DRIZZLE_API
drizzle_result_st *drizzle_shutdown(drizzle_con_st *con,
drizzle_result_st *result, uint32_t level,
drizzle_return_t *ret_ptr);
/**
* Send a ping request to the server.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] result Caller allocated structure, or NULL to allocate one.
* @param[out] ret_ptr Standard drizzle return value.
* @return On success, a pointer to the (possibly allocated) structure. On
* failure this will be NULL.
*/
DRIZZLE_API
drizzle_result_st *drizzle_con_ping(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_return_t *ret_ptr);
/**
* @todo Remove this with next major API change.
*/
DRIZZLE_API
drizzle_result_st *drizzle_ping(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_return_t *ret_ptr);
/**
* Send raw command to server, possibly in parts.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] result Caller allocated structure, or NULL to allocate one.
* @param[in] command Command to run on server.
* @param[in] data Data to send along with the command.
* @param[in] size Size of the current chunk of data being sent.
* @param[in] total Total size of all data being sent for command.
* @param[out] ret_ptr Standard drizzle return value.
* @return On success, a pointer to the (possibly allocated) structure. On
* failure this will be NULL.
*/
DRIZZLE_API
drizzle_result_st *drizzle_con_command_write(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_command_t command,
const void *data, size_t size,
size_t total,
drizzle_return_t *ret_ptr);
/** @} */
#ifdef __cplusplus
}
#endif

118
utils/mysqlcl_idb/libdrizzle-2.0/conn_local.h
View File

@ -1,118 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Local Connection Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_con_local Local Connection Declarations
* @ingroup drizzle_con
* @{
*/
/**
* Clear address info, freeing structs if needed.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
*/
DRIZZLE_LOCAL
void drizzle_con_reset_addrinfo(drizzle_con_st *con);
/**
* Check if state stack is empty.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return True if empty, false if something is on the stack.
*/
static inline bool drizzle_state_none(drizzle_con_st *con)
{
return con->state_current == 0;
}
/**
* Push a function onto the stack.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] function Function to push.
*/
static inline void drizzle_state_push(drizzle_con_st *con,
drizzle_state_fn *function)
{
/* The maximum stack depth can be determined at compile time, so bump this
constant if needed to avoid the dynamic memory management. */
assert(con->state_current < DRIZZLE_STATE_STACK_SIZE);
con->state_stack[con->state_current]= function;
con->state_current++;
}
/**
* Pop a function off of the stack.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
*/
static inline void drizzle_state_pop(drizzle_con_st *con)
{
con->state_current--;
}
/**
* Reset the stack so it is empty.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
*/
static inline void drizzle_state_reset(drizzle_con_st *con)
{
con->state_current= 0;
}
/** @} */
#ifdef __cplusplus
}
#endif

224
utils/mysqlcl_idb/libdrizzle-2.0/conn_server.h
View File

@ -1,224 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Connection Declarations for Servers
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_con_server Connection Declarations for Servers
* @ingroup drizzle_server_interface
*
* These functions extend the core connection functions with a set of functions
* for server application use. These functions allow you to set raw handshake
* information for use with the handshake write functions.
* @{
*/
/**
* Put a connection into listening mode.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_con_listen(drizzle_con_st *con);
/**
* Get connection backlog queue length.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Backlog for connection
*/
DRIZZLE_API
int drizzle_con_backlog(const drizzle_con_st *con);
/**
* Set connection backlog queue length.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] backlog Backlog to use for connection
*/
DRIZZLE_API
void drizzle_con_set_backlog(drizzle_con_st *con, int backlog);
/**
* Set protocol version for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] protocol_version Protocol version to use for connection
*/
DRIZZLE_API
void drizzle_con_set_protocol_version(drizzle_con_st *con,
uint8_t protocol_version);
/**
* Set server version string for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] server_version Server version to use for connection
*/
DRIZZLE_API
void drizzle_con_set_server_version(drizzle_con_st *con,
const char *server_version);
/**
* Set thread ID for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] thread_id Thread ID to use for connection
*/
DRIZZLE_API
void drizzle_con_set_thread_id(drizzle_con_st *con, uint32_t thread_id);
/**
* Set scramble buffer for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] scramble Scramble to use for connection
*/
DRIZZLE_API
void drizzle_con_set_scramble(drizzle_con_st *con, const uint8_t *scramble);
/**
* Set capabilities for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] capabilities Capabilities to use for connection
*/
DRIZZLE_API
void drizzle_con_set_capabilities(drizzle_con_st *con,
int capabilities);
/**
* Set charset for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] charset Character set to use for connection
*/
DRIZZLE_API
void drizzle_con_set_charset(drizzle_con_st *con, drizzle_charset_t charset);
/**
* Set status for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] status Status to use for connection
*/
DRIZZLE_API
void drizzle_con_set_status(drizzle_con_st *con, drizzle_con_status_t status);
/**
* Set max packet size for a connection.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] max_packet_size Max packet size to use for connection
*/
DRIZZLE_API
void drizzle_con_set_max_packet_size(drizzle_con_st *con,
uint32_t max_packet_size);
/**
* Copy all handshake information from one connection into another.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[in] from Connection structure to copy from.
*/
DRIZZLE_API
void drizzle_con_copy_handshake(drizzle_con_st *con, drizzle_con_st *from);
/**
* Read command without buffering.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[out] command Command that was read.
* @param[out] offset Where the data being returned begins in the command data.
* @param[out] size The size of the data chunk being returned.
* @param[out] total The total size of all command data being read.
* @param[out] ret_ptr Standard drizzle return value.
* @return On success, a pointer to an internal buffer with the command data.
* It will be *size bytes in length.
*/
DRIZZLE_API
void *drizzle_con_command_read(drizzle_con_st *con,
drizzle_command_t *command, size_t *offset,
size_t *size, size_t *total,
drizzle_return_t *ret_ptr);
/**
* Read command and buffer it.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @param[out] command Command that was read.
* @param[out] total The total size of all command data being read.
* @param[out] ret_ptr Standard drizzle return value.
* @return On success, allocated buffer that holds the command data of length
* *total.
*/
DRIZZLE_API
void *drizzle_con_command_buffer(drizzle_con_st *con,
drizzle_command_t *command, size_t *total,
drizzle_return_t *ret_ptr);
DRIZZLE_API
void drizzle_con_command_buffer_free(uint8_t *command_buffer);
/** @} */
#ifdef __cplusplus
}
#endif

474
utils/mysqlcl_idb/libdrizzle-2.0/constants.h
View File

@ -1,474 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2011 Brian Aker (brian@tangent.org)
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Defines, typedefs, enums, and macros
*/
#include <unistd.h>
#ifdef __cplusplus
#include <vector>
extern "C" {
#endif
/**
* @addtogroup drizzle_constants Constants
* @ingroup drizzle_client_interface
* @ingroup drizzle_server_interface
* @{
*/
/* Defines. */
#define DRIZZLE_DEFAULT_TCP_HOST "localhost"
#define DRIZZLE_DEFAULT_TCP_PORT 4427
#define DRIZZLE_DEFAULT_TCP_PORT_MYSQL 4427
#define DRIZZLE_DEFAULT_UDS "/tmp/drizzle.sock"
#define DRIZZLE_DEFAULT_UDS_MYSQL "/tmp/mysql.sock"
#define DRIZZLE_DEFAULT_BACKLOG 64
#define DRIZZLE_BUFFER_COPY_THRESHOLD 8192
#define DRIZZLE_ROW_GROW_SIZE 8192
#define DRIZZLE_STATE_STACK_SIZE 8
#define DRIZZLE_DEFAULT_SOCKET_TIMEOUT 10
#define DRIZZLE_DEFAULT_SOCKET_SEND_SIZE 32768
#define DRIZZLE_DEFAULT_SOCKET_RECV_SIZE 32768
#define DRIZZLE_MYSQL_PASSWORD_HASH 41
#include <libdrizzle-2.0/deprecated_enum.h>
#include <libdrizzle-2.0/return.h>
#include <libdrizzle-2.0/command.h>
#include <libdrizzle-2.0/verbose.h>
#include <libdrizzle-2.0/limits.h>
/** @} */
/**
* @ingroup drizzle_con
* Options for drizzle_con_st.
*/
enum drizzle_con_options_t
{
DRIZZLE_CON_NONE= 0,
DRIZZLE_CON_ALLOCATED= (1 << 0), // DEPRECATED
DRIZZLE_CON_MYSQL= (1 << 1),
DRIZZLE_CON_RAW_PACKET= (1 << 2),
DRIZZLE_CON_RAW_SCRAMBLE= (1 << 3),
DRIZZLE_CON_READY= (1 << 4),
DRIZZLE_CON_NO_RESULT_READ= (1 << 5),
DRIZZLE_CON_IO_READY= (1 << 6),
DRIZZLE_CON_LISTEN= (1 << 7),
DRIZZLE_CON_EXPERIMENTAL= (1 << 8),
DRIZZLE_CON_FOUND_ROWS= (1 << 9),
DRIZZLE_CON_INTERACTIVE= (1 << 11),
DRIZZLE_CON_MULTI_STATEMENTS= (1 << 12),
DRIZZLE_CON_AUTH_PLUGIN= (1 << 13)
};
#ifndef __cplusplus
typedef enum drizzle_con_options_t drizzle_con_options_t;
#endif
/**
* @ingroup drizzle_con
* Socket types for drizzle_con_st.
*/
enum drizzle_con_socket_t
{
DRIZZLE_CON_SOCKET_TCP,
DRIZZLE_CON_SOCKET_UDS
};
#ifndef __cplusplus
typedef enum drizzle_con_socket_t drizzle_con_socket_t;
#endif
/**
* @ingroup drizzle_con
* Status flags for drizle_con_st.
*/
enum drizzle_con_status_t
{
DRIZZLE_CON_STATUS_NONE= 0,
DRIZZLE_CON_STATUS_IN_TRANS= (1 << 0),
DRIZZLE_CON_STATUS_AUTOCOMMIT= (1 << 1),
DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS= (1 << 3),
DRIZZLE_CON_STATUS_QUERY_NO_GOOD_INDEX_USED= (1 << 4),
DRIZZLE_CON_STATUS_QUERY_NO_INDEX_USED= (1 << 5),
DRIZZLE_CON_STATUS_CURSOR_EXISTS= (1 << 6),
DRIZZLE_CON_STATUS_LAST_ROW_SENT= (1 << 7),
DRIZZLE_CON_STATUS_DB_DROPPED= (1 << 8),
DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES= (1 << 9),
DRIZZLE_CON_STATUS_QUERY_WAS_SLOW= (1 << 10)
};
#ifndef __cplusplus
typedef enum drizzle_con_status_t drizzle_con_status_t;
#endif
/**
* @ingroup drizzle_con
* Capabilities for drizzle_con_st.
*/
enum drizzle_capabilities_t
{
DRIZZLE_CAPABILITIES_NONE= 0,
DRIZZLE_CAPABILITIES_LONG_PASSWORD= (1 << 0),
DRIZZLE_CAPABILITIES_FOUND_ROWS= (1 << 1),
DRIZZLE_CAPABILITIES_LONG_FLAG= (1 << 2),
DRIZZLE_CAPABILITIES_CONNECT_WITH_DB= (1 << 3),
DRIZZLE_CAPABILITIES_NO_SCHEMA= (1 << 4),
DRIZZLE_CAPABILITIES_COMPRESS= (1 << 5),
DRIZZLE_CAPABILITIES_ODBC= (1 << 6),
DRIZZLE_CAPABILITIES_LOCAL_FILES= (1 << 7),
DRIZZLE_CAPABILITIES_IGNORE_SPACE= (1 << 8),
DRIZZLE_CAPABILITIES_PROTOCOL_41= (1 << 9),
DRIZZLE_CAPABILITIES_INTERACTIVE= (1 << 10),
DRIZZLE_CAPABILITIES_SSL= (1 << 11),
DRIZZLE_CAPABILITIES_IGNORE_SIGPIPE= (1 << 12),
DRIZZLE_CAPABILITIES_TRANSACTIONS= (1 << 13),
DRIZZLE_CAPABILITIES_RESERVED= (1 << 14),
DRIZZLE_CAPABILITIES_SECURE_CONNECTION= (1 << 15),
DRIZZLE_CAPABILITIES_MULTI_STATEMENTS= (1 << 16),
DRIZZLE_CAPABILITIES_MULTI_RESULTS= (1 << 17),
DRIZZLE_CAPABILITIES_PS_MULTI_RESULTS= (1 << 18),
DRIZZLE_CAPABILITIES_PLUGIN_AUTH= (1 << 19),
DRIZZLE_CAPABILITIES_SSL_VERIFY_SERVER_CERT= (1 << 30),
DRIZZLE_CAPABILITIES_REMEMBER_OPTIONS= (1 << 31),
DRIZZLE_CAPABILITIES_CLIENT= (DRIZZLE_CAPABILITIES_LONG_PASSWORD |
DRIZZLE_CAPABILITIES_FOUND_ROWS |
DRIZZLE_CAPABILITIES_LONG_FLAG |
DRIZZLE_CAPABILITIES_CONNECT_WITH_DB |
DRIZZLE_CAPABILITIES_PLUGIN_AUTH |
DRIZZLE_CAPABILITIES_TRANSACTIONS |
DRIZZLE_CAPABILITIES_PROTOCOL_41 |
DRIZZLE_CAPABILITIES_SECURE_CONNECTION)
};
#ifndef __cplusplus
typedef enum drizzle_capabilities_t drizzle_capabilities_t;
#endif
/**
* @ingroup drizzle_query
* States for drizle_query_st.
*/
enum drizzle_query_state_t
{
DRIZZLE_QUERY_STATE_INIT,
DRIZZLE_QUERY_STATE_QUERY,
DRIZZLE_QUERY_STATE_RESULT,
DRIZZLE_QUERY_STATE_DONE
};
#ifndef __cplusplus
enum drizzle_query_state_t drizzle_query_state_t;
#endif
/**
* @ingroup drizzle_result
* Options for drizzle_result_st.
*/
enum drizzle_result_options_t
{
DRIZZLE_RESULT_NONE= 0,
DRIZZLE_RESULT_ALLOCATED= (1 << 0), // DEPRECATED
DRIZZLE_RESULT_SKIP_COLUMN= (1 << 1),
DRIZZLE_RESULT_BUFFER_COLUMN= (1 << 2),
DRIZZLE_RESULT_BUFFER_ROW= (1 << 3),
DRIZZLE_RESULT_EOF_PACKET= (1 << 4),
DRIZZLE_RESULT_ROW_BREAK= (1 << 5)
};
#ifndef __cplusplus
typedef enum drizzle_result_options_t drizzle_result_options_t;
#endif
/**
* @ingroup drizzle_column
* Options for drizzle_column_st.
*/
enum drizzle_column_options_t
{
DRIZZLE_COLUMN_ALLOCATED= (1 << 0) // DEPRECATED
};
#ifndef __cplusplus
typedef enum drizzle_column_options_t drizzle_column_options_t;
#endif
/**
* @ingroup drizzle_column
* Types for drizzle_column_st.
*/
enum drizzle_column_type_t
{
DRIZZLE_COLUMN_TYPE_DECIMAL,
DRIZZLE_COLUMN_TYPE_TINY,
DRIZZLE_COLUMN_TYPE_SHORT,
DRIZZLE_COLUMN_TYPE_LONG,
DRIZZLE_COLUMN_TYPE_FLOAT,
DRIZZLE_COLUMN_TYPE_DOUBLE,
DRIZZLE_COLUMN_TYPE_NULL,
DRIZZLE_COLUMN_TYPE_TIMESTAMP,
DRIZZLE_COLUMN_TYPE_LONGLONG,
DRIZZLE_COLUMN_TYPE_INT24,
DRIZZLE_COLUMN_TYPE_DATE,
DRIZZLE_COLUMN_TYPE_TIME,
DRIZZLE_COLUMN_TYPE_DATETIME,
DRIZZLE_COLUMN_TYPE_YEAR,
DRIZZLE_COLUMN_TYPE_NEWDATE,
DRIZZLE_COLUMN_TYPE_VARCHAR,
DRIZZLE_COLUMN_TYPE_BIT,
DRIZZLE_COLUMN_TYPE_NEWDECIMAL= 246,
DRIZZLE_COLUMN_TYPE_ENUM= 247,
DRIZZLE_COLUMN_TYPE_SET= 248,
DRIZZLE_COLUMN_TYPE_TINY_BLOB= 249,
DRIZZLE_COLUMN_TYPE_MEDIUM_BLOB= 250,
DRIZZLE_COLUMN_TYPE_LONG_BLOB= 251,
DRIZZLE_COLUMN_TYPE_BLOB= 252,
DRIZZLE_COLUMN_TYPE_VAR_STRING= 253,
DRIZZLE_COLUMN_TYPE_STRING= 254,
DRIZZLE_COLUMN_TYPE_GEOMETRY= 255
};
#ifndef __cplusplus
typedef enum drizzle_column_type_t drizzle_column_type_t;
#endif
/**
* @ingroup drizzle_column
* Types for drizzle_column_st for Drizzle.
*/
enum drizzle_column_type_drizzle_t
{
DRIZZLE_COLUMN_TYPE_DRIZZLE_TINY,
DRIZZLE_COLUMN_TYPE_DRIZZLE_LONG,
DRIZZLE_COLUMN_TYPE_DRIZZLE_DOUBLE,
DRIZZLE_COLUMN_TYPE_DRIZZLE_NULL,
DRIZZLE_COLUMN_TYPE_DRIZZLE_TIMESTAMP,
DRIZZLE_COLUMN_TYPE_DRIZZLE_LONGLONG,
DRIZZLE_COLUMN_TYPE_DRIZZLE_DATETIME,
DRIZZLE_COLUMN_TYPE_DRIZZLE_DATE,
DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR,
DRIZZLE_COLUMN_TYPE_DRIZZLE_NEWDECIMAL,
DRIZZLE_COLUMN_TYPE_DRIZZLE_ENUM,
DRIZZLE_COLUMN_TYPE_DRIZZLE_BLOB,
DRIZZLE_COLUMN_TYPE_DRIZZLE_TIME,
DRIZZLE_COLUMN_TYPE_DRIZZLE_BOOLEAN,
DRIZZLE_COLUMN_TYPE_DRIZZLE_UUID,
DRIZZLE_COLUMN_TYPE_DRIZZLE_MICROTIME,
DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX=DRIZZLE_COLUMN_TYPE_DRIZZLE_MICROTIME
};
#ifndef __cplusplus
typedef enum drizzle_column_type_drizzle_t drizzle_column_type_drizzle_t;
#endif
/**
* @ingroup drizzle_column
* Flags for drizzle_column_st.
*/
enum drizzle_column_flags_t
{
DRIZZLE_COLUMN_FLAGS_NONE= 0,
DRIZZLE_COLUMN_FLAGS_NOT_NULL= (1 << 0),
DRIZZLE_COLUMN_FLAGS_PRI_KEY= (1 << 1),
DRIZZLE_COLUMN_FLAGS_UNIQUE_KEY= (1 << 2),
DRIZZLE_COLUMN_FLAGS_MULTIPLE_KEY= (1 << 3),
DRIZZLE_COLUMN_FLAGS_BLOB= (1 << 4),
DRIZZLE_COLUMN_FLAGS_UNSIGNED= (1 << 5),
DRIZZLE_COLUMN_FLAGS_ZEROFILL= (1 << 6),
DRIZZLE_COLUMN_FLAGS_BINARY= (1 << 7),
DRIZZLE_COLUMN_FLAGS_ENUM= (1 << 8),
DRIZZLE_COLUMN_FLAGS_AUTO_INCREMENT= (1 << 9),
DRIZZLE_COLUMN_FLAGS_TIMESTAMP= (1 << 10),
DRIZZLE_COLUMN_FLAGS_SET= (1 << 11),
DRIZZLE_COLUMN_FLAGS_NO_DEFAULT_VALUE= (1 << 12),
DRIZZLE_COLUMN_FLAGS_ON_UPDATE_NOW= (1 << 13),
DRIZZLE_COLUMN_FLAGS_PART_KEY= (1 << 14),
DRIZZLE_COLUMN_FLAGS_NUM= (1 << 15),
DRIZZLE_COLUMN_FLAGS_GROUP= (1 << 15), /* NUM & GROUP the same. */
DRIZZLE_COLUMN_FLAGS_UNIQUE= (1 << 16),
DRIZZLE_COLUMN_FLAGS_BINCMP= (1 << 17),
DRIZZLE_COLUMN_FLAGS_GET_FIXED_FIELDS= (1 << 18),
DRIZZLE_COLUMN_FLAGS_IN_PART_FUNC= (1 << 19),
DRIZZLE_COLUMN_FLAGS_IN_ADD_INDEX= (1 << 20),
DRIZZLE_COLUMN_FLAGS_RENAMED= (1 << 21)
};
#ifndef __cplusplus
typedef enum drizzle_column_flags_t drizzle_column_flags_t;
#endif
/**
* @addtogroup drizzle_types Types
* @ingroup drizzle_client_interface
* @ingroup drizzle_server_interface
* @{
*/
/* Types. */
#ifndef __cplusplus
typedef struct drizzle_st drizzle_st;
typedef struct drizzle_con_tcp_st drizzle_con_tcp_st;
typedef struct drizzle_con_uds_st drizzle_con_uds_st;
typedef struct drizzle_con_st drizzle_con_st;
typedef struct drizzle_query_st drizzle_query_st;
typedef struct drizzle_result_st drizzle_result_st;
typedef struct drizzle_column_st drizzle_column_st;
#else
class drizzle_st;
class drizzle_con_tcp_st;
class drizzle_con_uds_st;
class drizzle_con_st;
class drizzle_query_st;
class drizzle_result_st;
class drizzle_column_st;
#endif
typedef char drizzle_field_t_type;
typedef drizzle_field_t_type *drizzle_field_t;
typedef drizzle_field_t drizzle_row_t_type;
typedef drizzle_row_t_type *drizzle_row_t;
typedef size_t * drizzle_field_sizes_type;
typedef uint8_t drizzle_charset_t;
#if defined(__cplusplus)
typedef ::std::vector<drizzle_row_t> drizzle_row_list_t;
typedef ::std::vector<drizzle_field_sizes_type> drizzle_field_sizes_list_t;
#else
typedef void drizzle_row_list_t;
typedef void drizzle_field_sizes_list_t;
#endif
/* Function types. */
typedef void (drizzle_context_free_fn)(drizzle_st *drizzle, void *context);
typedef void (drizzle_log_fn)(const char *line, drizzle_verbose_t verbose, void *context);
typedef drizzle_return_t (drizzle_state_fn)(drizzle_con_st *con);
typedef void (drizzle_con_context_free_fn)(drizzle_con_st *con, void *context);
typedef void (drizzle_query_context_free_fn)(drizzle_query_st *query, void *context);
/**
* Custom function to register or deregister interest in file descriptor
* events. See drizzle_set_event_watch_fn().
*
* @param[in] con Connection that has changed the events it is interested in.
* Use drizzle_con_fd() to get the file descriptor.
* @param[in] events A bit mask of POLLIN | POLLOUT, specifying if the
* connection is waiting for read or write events.
* @param[in] context Application context pointer registered with
* drizzle_set_event_watch_fn().
* @return DRIZZLE_RETURN_OK if successful.
*/
typedef drizzle_return_t (drizzle_event_watch_fn)(drizzle_con_st *con,
short events,
void *context);
/** @} */
/**
* @addtogroup drizzle_macros Macros
* @ingroup drizzle_client_interface
* @ingroup drizzle_server_interface
* @{
*/
/* Protocol unpacking macros. */
#define drizzle_get_byte2(__buffer) \
(uint16_t)((__buffer)[0] | \
((__buffer)[1] << 8))
#define drizzle_get_byte3(__buffer) \
(uint32_t)((__buffer)[0] | \
((__buffer)[1] << 8) | \
((__buffer)[2] << 16))
#define drizzle_get_byte4(__buffer) \
(uint32_t)((__buffer)[0] | \
((__buffer)[1] << 8) | \
((__buffer)[2] << 16) | \
((__buffer)[3] << 24))
#define drizzle_get_byte8(__buffer) \
((uint64_t)(__buffer)[0] | \
((uint64_t)(__buffer)[1] << 8) | \
((uint64_t)(__buffer)[2] << 16) | \
((uint64_t)(__buffer)[3] << 24) | \
((uint64_t)(__buffer)[4] << 32) | \
((uint64_t)(__buffer)[5] << 40) | \
((uint64_t)(__buffer)[6] << 48) | \
((uint64_t)(__buffer)[7] << 56))
/* Protocol packing macros. */
#define drizzle_set_byte2(__buffer, __int) do { \
(__buffer)[0]= (uint8_t)((__int) & 0xFF); \
(__buffer)[1]= (uint8_t)(((__int) >> 8) & 0xFF); } while (0)
#define drizzle_set_byte3(__buffer, __int) do { \
(__buffer)[0]= (uint8_t)((__int) & 0xFF); \
(__buffer)[1]= (uint8_t)(((__int) >> 8) & 0xFF); \
(__buffer)[2]= (uint8_t)(((__int) >> 16) & 0xFF); } while (0)
#define drizzle_set_byte4(__buffer, __int) do { \
(__buffer)[0]= (uint8_t)((__int) & 0xFF); \
(__buffer)[1]= (uint8_t)(((__int) >> 8) & 0xFF); \
(__buffer)[2]= (uint8_t)(((__int) >> 16) & 0xFF); \
(__buffer)[3]= (uint8_t)(((__int) >> 24) & 0xFF); } while (0)
#define drizzle_set_byte8(__buffer, __int) do { \
(__buffer)[0]= (uint8_t)((__int) & 0xFF); \
(__buffer)[1]= (uint8_t)(((__int) >> 8) & 0xFF); \
(__buffer)[2]= (uint8_t)(((__int) >> 16) & 0xFF); \
(__buffer)[3]= (uint8_t)(((__int) >> 24) & 0xFF); \
(__buffer)[4]= (uint8_t)(((__int) >> 32) & 0xFF); \
(__buffer)[5]= (uint8_t)(((__int) >> 40) & 0xFF); \
(__buffer)[6]= (uint8_t)(((__int) >> 48) & 0xFF); \
(__buffer)[7]= (uint8_t)(((__int) >> 56) & 0xFF); } while (0)
/* Multi-byte character macros. */
#define drizzle_mb_char(__c) (((__c) & 0x80) != 0)
#define drizzle_mb_length(__c) \
((uint32_t)(__c) <= 0x7f ? 1 : \
((uint32_t)(__c) <= 0x7ff ? 2 : \
((uint32_t)(__c) <= 0xd7ff ? 3 : \
((uint32_t)(__c) <= 0xdfff || (uint32_t)(__c) > 0x10ffff ? 0 : \
((uint32_t)(__c) <= 0xffff ? 3 : 4)))))
/** @} */
#ifdef __cplusplus
}
#endif

67
utils/mysqlcl_idb/libdrizzle-2.0/deprecated_enum.h
View File

@ -1,67 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2011 Brian Aker (brian@tangent.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @ingroup drizzle_query
* Options for drizzle_query_st.
*/
enum drizzle_query_options_t
{
DRIZZLE_QUERY_NONE,
DRIZZLE_QUERY_ALLOCATED
};
#ifndef __cplusplus
typedef enum drizzle_query_options_t drizzle_query_options_t;
#endif
/**
* @ingroup drizzle
* Options for drizzle_st.
*/
enum drizzle_options_t
{
DRIZZLE_NON_BLOCKING,
DRIZZLE_FREE_OBJECTS,
DRIZZLE_ASSERT_DANGLING
};
#ifndef __cplusplus
typedef enum drizzle_options_t drizzle_options_t;
#endif

397
utils/mysqlcl_idb/libdrizzle-2.0/drizzle.h
View File

@ -1,397 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Drizzle Declarations
*/
#include <sys/types.h>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# define NOMINMAX
# include <Windows.h>
# include <winsock2.h>
# include <ws2tcpip.h>
# include <io.h>
# undef close
# define close _close
typedef unsigned int in_port_t;
//typedef long ssize_t;
# define snprintf _snprintf
struct sockaddr_un
{
short int sun_family;
char sun_path[108];
};
//# define poll WSAPoll
//# define pollfd WSAPOLLFD
#if defined(__GNUC__)
# include <stdbool.h>
#else
# if !defined(__cplusplus)
typedef enum { false = 0, true = 1 } _Bool;
typedef _Bool bool;
#endif
#endif
#else
# if !defined(__cplusplus)
# include <stdbool.h>
# endif
# include <inttypes.h>
# include <sys/socket.h>
# include <netinet/in.h>
# include <arpa/inet.h>
# include <sys/un.h>
# include <netdb.h>
# include <poll.h>
#endif
#include <assert.h>
#include <errno.h>
#include <libdrizzle-2.0/visibility.h>
#include <libdrizzle-2.0/constants.h>
#include <libdrizzle-2.0/structs.h>
#include <libdrizzle-2.0/conn.h>
#include <libdrizzle-2.0/result.h>
#include <libdrizzle-2.0/column.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle Drizzle Declarations
* @ingroup drizzle_client_interface
* @ingroup drizzle_server_interface
*
* This is the core library structure that other structures (such as
* connections) are created from.
*
* There is no locking within a single drizzle_st structure, so for threaded
* applications you must either ensure isolation in the application or use
* multiple drizzle_st structures (for example, one for each thread).
* @{
*/
/**
* Get library version string.
*
* @return Pointer to static buffer in library that holds the version string.
*/
DRIZZLE_API
const char *drizzle_version(void);
/**
* Get bug report URL.
*
* @return Bug report URL string.
*/
DRIZZLE_API
const char *drizzle_bugreport(void);
/**
* Get string with the name of the given verbose level.
*
* @param[in] verbose Verbose logging level.
* @return String form of verbose level.
*/
DRIZZLE_API
const char *drizzle_verbose_name(drizzle_verbose_t verbose);
/**
* Initialize a drizzle structure. Always check the return value even if passing
* in a pre-allocated structure. Some other initialization may have failed.
*
* @param[in] drizzle Caller allocated structure, or NULL to allocate one.
* @return On success, a pointer to the (possibly allocated) structure. On
* failure this will be NULL.
*/
DRIZZLE_API
drizzle_st *drizzle_create();
/**
* Clone a drizzle structure.
*
* @param[in] drizzle Caller allocated structure, or NULL to allocate one.
* @param[in] from Drizzle structure to use as a source to clone from.
* @return Same return as drizzle_create().
*/
DRIZZLE_API
drizzle_st *drizzle_clone(const drizzle_st *from);
/**
* Free a drizzle structure.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
*/
DRIZZLE_API
void drizzle_free(drizzle_st *drizzle);
/**
* Return an error string for last error encountered.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return Pointer to static buffer in library that holds an error string.
*/
DRIZZLE_API
const char *drizzle_error(const drizzle_st *drizzle);
/**
* Value of errno in the case of a DRIZZLE_RETURN_ERRNO return value.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return An errno value as defined in your system errno.h file.
*/
DRIZZLE_API
int drizzle_errno(const drizzle_st *drizzle);
/**
* Get server defined error code for the last result read.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return An error code given back in the server response.
*/
DRIZZLE_API
uint16_t drizzle_error_code(const drizzle_st *drizzle);
/**
* Get SQL state code for the last result read.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return A SQLSTATE code given back in the server response.
*/
DRIZZLE_API
const char *drizzle_sqlstate(const drizzle_st *drizzle);
/**
* Get application context pointer.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return Application context that was previously set, or NULL.
*/
DRIZZLE_API
void *drizzle_context(const drizzle_st *drizzle);
/**
* Set application context pointer.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] context Application context to set.
*/
DRIZZLE_API
void drizzle_set_context(drizzle_st *drizzle, void *context);
/**
* Set function to call when the drizzle structure is being cleaned up so
* the application can clean up the context pointer.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] function Function to call to clean up drizzle context.
*/
DRIZZLE_API
void drizzle_set_context_free_fn(drizzle_st *drizzle,
drizzle_context_free_fn *function);
/**
* Get current socket I/O activity timeout value.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return Timeout in milliseconds to wait for I/O activity. A negative value
* means an infinite timeout.
*/
DRIZZLE_API
int drizzle_timeout(const drizzle_st *drizzle);
/**
* Set socket I/O activity timeout for connections in a Drizzle structure.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] timeout Milliseconds to wait for I/O activity. A negative value
* means an infinite timeout.
*/
DRIZZLE_API
void drizzle_set_timeout(drizzle_st *drizzle, int timeout);
/**
* Get current verbosity threshold for logging messages.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return Current verbosity threshold.
*/
DRIZZLE_API
drizzle_verbose_t drizzle_verbose(const drizzle_st *drizzle);
/**
* Set verbosity threshold for logging messages. If this is set above
* DRIZZLE_VERBOSE_NEVER and the drizzle_set_log_fn() callback is set to NULL,
* messages are printed to STDOUT.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] verbose Verbosity threshold of what to log.
*/
DRIZZLE_API
void drizzle_set_verbose(drizzle_st *drizzle, drizzle_verbose_t verbose);
/**
* Set logging function for a drizzle structure. This function is only called
* for log messages that are above the verbosity threshold set with
* drizzle_set_verbose().
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] function Function to call when there is a logging message.
* @param[in] context Argument to pass into the callback function.
*/
DRIZZLE_API
void drizzle_set_log_fn(drizzle_st *drizzle, drizzle_log_fn *function,
void *context);
/**
* Set a custom I/O event watcher function for a drizzle structure. Used to
* integrate libdrizzle with a custom event loop. The callback will be invoked
* to register or deregister interest in events for a connection. When the
* events are triggered, drizzle_con_set_revents() should be called to
* indicate which events are ready. The event loop should stop waiting for
* these events, as libdrizzle will call the callback again if it is still
* interested. To resume processing, the libdrizzle function that returned
* DRIZZLE_RETURN_IO_WAIT should be called again. See drizzle_event_watch_fn().
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] function Function to call when there is an I/O event.
* @param[in] context Argument to pass into the callback function.
*/
DRIZZLE_API
void drizzle_set_event_watch_fn(drizzle_st *drizzle,
drizzle_event_watch_fn *function,
void *context);
/**
* Initialize a connection structure. Always check the return value even if
* passing in a pre-allocated structure. Some other initialization may have
* failed.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] con Caller allocated structure, or NULL to allocate one.
* @return On success, a pointer to the (possibly allocated) structure. On
* failure this will be NULL.
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_create(drizzle_st *drizzle);
/**
* Clone a connection structure.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] con Caller allocated structure, or NULL to allocate one.
* @param[in] from Connection structure to use as a source to clone from.
* @return Same return as drizzle_con_create().
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *con);
DRIZZLE_API
drizzle_return_t drizzle_set_option(drizzle_st *drizzle, drizzle_options_t arg, bool set);
/**
* Free a connection structure.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
*/
DRIZZLE_API
void drizzle_con_free(drizzle_con_st *con);
/**
* Free all connections in a drizzle structure.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
*/
DRIZZLE_API
void drizzle_con_free_all(drizzle_st *drizzle);
/**
* Wait for I/O on connections.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_con_wait(drizzle_st *drizzle);
/**
* Get next connection that is ready for I/O.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return Connection that is ready for I/O, or NULL if there are none.
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_ready(drizzle_st *drizzle);
/** @} */
#ifdef __cplusplus
}
#endif

113
utils/mysqlcl_idb/libdrizzle-2.0/drizzle_client.h
View File

@ -1,113 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Drizzle Declarations for Clients
*/
#include <libdrizzle-2.0/drizzle.h>
#include <libdrizzle-2.0/conn_client.h>
#include <libdrizzle-2.0/handshake_client.h>
#include <libdrizzle-2.0/command_client.h>
#include <libdrizzle-2.0/query.h>
#include <libdrizzle-2.0/result_client.h>
#include <libdrizzle-2.0/column_client.h>
#include <libdrizzle-2.0/row_client.h>
#include <libdrizzle-2.0/field_client.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup drizzle_client_interface Drizzle Client Interface
*/
/**
* @addtogroup drizzle_client Drizzle Declarations for Clients
* @ingroup drizzle_client_interface
* @{
*/
/**
* Add TCP (IPv4 or IPv6) connection with common arguments.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] con Caller allocated structure, or NULL to allocate one.
* @param[in] host Host to connect to. This may be a hostname to resolve, an
* IPv4 address, or an IPv6 address. This is passed directly to getaddrinfo().
* @param[in] port Remote port to connect to.
* @param[in] user User to use while establishing the connection.
* @param[in] password Password to use while establishing the connection.
* @param[in] db Initial database to connect to.
* @param[in] options Drizzle connection options to add.
* @return Same return as drizzle_con_create().
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle,
const char *host, in_port_t port,
const char *user, const char *password,
const char *db,
drizzle_con_options_t options);
/**
* Add unix domain socket connection with common arguments.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] con Caller allocated structure, or NULL to allocate one.
* @param[in] uds Path to unix domain socket to use for connection.
* @param[in] user User to use while establishing the connection.
* @param[in] password Password to use while establishing the connection.
* @param[in] db Initial database to connect to.
* @param[in] options Drizzle connection options to add.
* @return Same return as drizzle_con_create().
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle,
const char *uds, const char *user,
const char *password, const char *db,
drizzle_con_options_t options);
/** @} */
#ifdef __cplusplus
}
#endif

163
utils/mysqlcl_idb/libdrizzle-2.0/drizzle_local.h
View File

@ -1,163 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Local Drizzle Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_local Local Drizzle Declarations
* @ingroup drizzle
* @{
*/
/**
* Set the error string.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] function Name of function the error happened in.
* @param[in] format Format and variable argument list of message.
*/
DRIZZLE_LOCAL
void drizzle_set_error(drizzle_st *drizzle, const char *function,
const char *format, ...);
/**
* Log a message.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] verbose Logging level of the message.
* @param[in] format Format and variable argument list of message.
* @param[in] args Variable argument list that has been initialized.
*/
DRIZZLE_LOCAL
void drizzle_log(drizzle_st *drizzle, drizzle_verbose_t verbose,
const char *format, va_list args);
/**
* Log a fatal message, see drizzle_log() for argument details.
*/
static inline void drizzle_log_fatal(drizzle_st *drizzle, const char *format,
...)
{
va_list args;
if (drizzle->verbose >= DRIZZLE_VERBOSE_FATAL)
{
va_start(args, format);
drizzle_log(drizzle, DRIZZLE_VERBOSE_FATAL, format, args);
va_end(args);
}
}
/**
* Log an error message, see drizzle_log() for argument details.
*/
static inline void drizzle_log_error(drizzle_st *drizzle, const char *format,
...)
{
va_list args;
if (drizzle->verbose >= DRIZZLE_VERBOSE_ERROR)
{
va_start(args, format);
drizzle_log(drizzle, DRIZZLE_VERBOSE_ERROR, format, args);
va_end(args);
}
}
/**
* Log an info message, see drizzle_log() for argument details.
*/
static inline void drizzle_log_info(drizzle_st *drizzle, const char *format,
...)
{
va_list args;
if (drizzle->verbose >= DRIZZLE_VERBOSE_INFO)
{
va_start(args, format);
drizzle_log(drizzle, DRIZZLE_VERBOSE_INFO, format, args);
va_end(args);
}
}
/**
* Log a debug message, see drizzle_log() for argument details.
*/
static inline void drizzle_log_debug(drizzle_st *drizzle, const char *format,
...)
{
va_list args;
if (drizzle->verbose >= DRIZZLE_VERBOSE_DEBUG)
{
va_start(args, format);
drizzle_log(drizzle, DRIZZLE_VERBOSE_DEBUG, format, args);
va_end(args);
}
}
/**
* Log a crazy message, see drizzle_log() for argument details.
*/
static inline void drizzle_log_crazy(drizzle_st *drizzle, const char *format,
...)
{
va_list args;
if (drizzle->verbose >= DRIZZLE_VERBOSE_CRAZY)
{
va_start(args, format);
drizzle_log(drizzle, DRIZZLE_VERBOSE_CRAZY, format, args);
va_end(args);
}
}
/** @} */
#ifdef __cplusplus
}
#endif

127
utils/mysqlcl_idb/libdrizzle-2.0/drizzle_server.h
View File

@ -1,127 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Drizzle Declarations for Servers
*/
#include <libdrizzle-2.0/drizzle.h>
#include <libdrizzle-2.0/conn_server.h>
#include <libdrizzle-2.0/handshake_server.h>
#include <libdrizzle-2.0/command_server.h>
#include <libdrizzle-2.0/result_server.h>
#include <libdrizzle-2.0/column_server.h>
#include <libdrizzle-2.0/row_server.h>
#include <libdrizzle-2.0/field_server.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup drizzle_server_interface Drizzle Server Interface
*/
/**
* @addtogroup drizzle_server Drizzle Declarations for Servers
* @ingroup drizzle_server_interface
* @{
*/
/**
* Add TCP (IPv4 or IPv6) connection for listening with common arguments.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] con Caller allocated structure, or NULL to allocate one.
* @param[in] host Host to listen on. This may be a hostname to resolve, an
* IPv4 address, or an IPv6 address. This is passed directly to getaddrinfo().
* @param[in] port Port to connect to.
* @param[in] backlog Number of backlog connections passed to listen().
* @param[in] options Drizzle connection options to add.
* @return Same return as drizzle_con_create().
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_add_tcp_listen(drizzle_st *drizzle,
const char *host, in_port_t port,
int backlog,
drizzle_con_options_t options);
/**
* Add unix domain socket connection for listening with common arguments.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[in] uds Path to unix domain socket to use for listening.
* @param[in] backlog Number of backlog connections passed to listen().
* @param[in] options Drizzle connection options to add.
* @return Same return as drizzle_con_create().
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_add_uds_listen(drizzle_st *drizzle,
const char *uds, int backlog,
drizzle_con_options_t options);
/**
* Get next connection marked for listening that is ready for I/O.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @return Connection that is ready to accept, or NULL if there are none.
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_ready_listen(drizzle_st *drizzle);
/**
* Accept a new connection and initialize the connection structure for it.
*
* @param[in] drizzle Drizzle structure previously initialized with
* drizzle_create() or drizzle_clone().
* @param[out] ret_ptr Standard drizzle return value.
* @return Same return as drizzle_con_create().
*/
DRIZZLE_API
drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle,
drizzle_return_t *ret_ptr);
/** @} */
#ifdef __cplusplus
}
#endif

85
utils/mysqlcl_idb/libdrizzle-2.0/field_client.h
View File

@ -1,85 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Field Declarations for Clients
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_field_client Field Declarations for Clients
* @ingroup drizzle_client_interface
*
* These functions allow you to access fields in a result set if the result is
* unbuffered. If the result is buffered, you can access the fields through the
* row functions.
* @{
*/
/**
* Read field for unbuffered result, possibly in parts. This is especially
* useful for blob streaming, since the client does not need to buffer the
* entire blob.
*/
DRIZZLE_API
drizzle_field_t drizzle_field_read(drizzle_result_st *result, size_t *offset,
size_t *size, size_t *total,
drizzle_return_t *ret_ptr);
/**
* Buffer one field.
*/
DRIZZLE_API
drizzle_field_t drizzle_field_buffer(drizzle_result_st *result, size_t *total,
drizzle_return_t *ret_ptr);
/**
* Free a buffered field.
*/
DRIZZLE_API
void drizzle_field_free(drizzle_field_t field);
/** @} */
#ifdef __cplusplus
}
#endif

65
utils/mysqlcl_idb/libdrizzle-2.0/field_server.h
View File

@ -1,65 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Field Declarations for Servers
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_field_server Field Declarations for Servers
* @ingroup drizzle_server_interface
*
* These functions allow you to send a field over a connection.
* @{
*/
DRIZZLE_API
drizzle_return_t drizzle_field_write(drizzle_result_st *result,
const drizzle_field_t field, size_t size,
size_t total);
/** @} */
#ifdef __cplusplus
}
#endif

82
utils/mysqlcl_idb/libdrizzle-2.0/handshake_client.h
View File

@ -1,82 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Handshake Declarations for Clients
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_handshake_client Handshake Declarations for Clients
* @ingroup drizzle_client_interface
*
* These functions are used to send and receive handshake packets for a client.
* These are only used by low-level clients when the DRIZZLE_CON_RAW_PACKET
* option is set, so most applications will never need to use these.
* @{
*/
/**
* Read handshake packet from the server in a client.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_handshake_server_read(drizzle_con_st *con);
/**
* Write client handshake packet to a server.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_handshake_client_write(drizzle_con_st *con);
/** @} */
#ifdef __cplusplus
}
#endif

80
utils/mysqlcl_idb/libdrizzle-2.0/handshake_server.h
View File

@ -1,80 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Handshake Declarations for Servers
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_handshake_server Handshake Declarations for Servers
* @ingroup drizzle_server_interface
*
* These functions are used to send and receive handshake packets in a server.
* @{
*/
/**
* Write server handshake packet to a client.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_handshake_server_write(drizzle_con_st *con);
/**
* Read handshake packet from the client in a server.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Standard drizzle return value.
*/
DRIZZLE_API
drizzle_return_t drizzle_handshake_client_read(drizzle_con_st *con);
/** @} */
#ifdef __cplusplus
}
#endif

36
utils/mysqlcl_idb/libdrizzle-2.0/libdrizzle.h
View File

@ -1,36 +0,0 @@
/* Drizzle Client Library
* Copyright (C) 2011 Olaf van der Spek
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <libdrizzle-2.0/drizzle_client.h>

385
utils/mysqlcl_idb/libdrizzle-2.0/libdrizzle.hpp
View File

@ -1,385 +0,0 @@
/* Drizzle Client Library
* Copyright (C) 2011 Olaf van der Spek
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <boost/algorithm/string.hpp>
#include <boost/foreach.hpp>
#include <boost/shared_ptr.hpp>
#include <cstring>
#include <fstream>
#include <libdrizzle-2.0/libdrizzle.h>
#include <map>
#include <sstream>
#include <stdexcept>
namespace drizzle {
class bad_query : public std::runtime_error
{
public:
bad_query(const std::string& v) : std::runtime_error(v)
{
}
};
class noncopyable
{
protected:
noncopyable()
{
}
private:
noncopyable(const noncopyable&);
void operator=(const noncopyable&);
};
class drizzle_c : noncopyable
{
public:
drizzle_c()
{
b_= drizzle_create();
}
~drizzle_c()
{
drizzle_free(b_);
}
operator drizzle_st*()
{
return b_;
}
private:
drizzle_st *b_;
};
class result_c
{
public:
operator drizzle_result_st*()
{
if (!b_)
b_.reset(new drizzle_result_st, drizzle_result_free);
return b_.get();
}
const char* error()
{
return drizzle_result_error(*this);
}
uint16_t error_code()
{
return drizzle_result_error_code(*this);
}
uint16_t column_count()
{
return drizzle_result_column_count(*this);
}
uint64_t row_count()
{
return drizzle_result_row_count(*this);
}
drizzle_column_st* column_next()
{
return drizzle_column_next(*this);
}
drizzle_row_t row_next()
{
return drizzle_row_next(*this);
}
void column_seek(uint16_t i)
{
drizzle_column_seek(*this, i);
}
void row_seek(uint64_t i)
{
drizzle_row_seek(*this, i);
}
size_t* row_field_sizes()
{
return drizzle_row_field_sizes(*this);
}
private:
boost::shared_ptr<drizzle_result_st> b_;
};
class connection_c : noncopyable
{
public:
explicit connection_c(drizzle_c& drizzle)
{
b_= drizzle_con_create(drizzle);
if (b_ == NULL)
{
throw "drizzle_con_create() failed";
}
read_conf_files();
}
~connection_c()
{
drizzle_con_free(b_);
}
operator drizzle_con_st*()
{
return b_;
}
const char* error()
{
return drizzle_con_error(b_);
}
void set_tcp(const char* host, in_port_t port)
{
drizzle_con_set_tcp(b_, host, port);
}
void set_auth(const char* user, const char* password)
{
drizzle_con_set_auth(b_, user, password);
}
void set_db(const char* db)
{
drizzle_con_set_db(b_, db);
}
drizzle_return_t query(result_c& result, const char* str, size_t str_size)
{
drizzle_return_t ret;
drizzle_query(*this, result, str, str_size, &ret);
if (!ret)
{
ret = drizzle_result_buffer(result);
}
return ret;
}
drizzle_return_t query(result_c& result, const std::string& str)
{
return query(result, str.data(), str.size());
}
drizzle_return_t query(result_c& result, const char* str)
{
return query(result, str, strlen(str));
}
result_c query(const char* str, size_t str_size)
{
result_c result;
if (query(result, str, str_size))
{
throw bad_query(error());
}
return result;
}
result_c query(const std::string& str)
{
return query(str.data(), str.size());
}
result_c query(const char* str)
{
return query(str, strlen(str));
}
private:
void read_conf_files();
drizzle_con_st *b_;
};
class query_c
{
public:
query_c(connection_c& con, const std::string& in = "") :
con_(con),
in_(in)
{
}
void operator=(const std::string& v)
{
in_ = v;
out_.clear();
}
void operator+=(const std::string& v)
{
in_ += v;
}
query_c& p_name(const std::string& v)
{
std::vector<char> r(2 * v.size() + 2);
r.resize(drizzle_escape_string(&r.front() + 1, r.size(), v.data(), v.size()) + 2);
r.front() = '`';
r.back() = '`';
p_raw(&r.front(), r.size());
return *this;
}
query_c& p_raw(const char* v, size_t sz)
{
size_t i = in_.find('?');
assert(i != std::string::npos);
if (i == std::string::npos)
return *this;
out_.append(in_.substr(0, i));
in_.erase(0, i + 1);
out_.append(v, sz);
return *this;
}
query_c& p_raw(const std::string& v)
{
return p_raw(v.data(), v.size());
}
query_c& p(const std::string& v)
{
std::vector<char> r(2 * v.size() + 2);
r.resize(drizzle_escape_string(&r.front() + 1, r.size(), v.data(), v.size()) + 2);
r.front() = '\'';
r.back() = '\'';
p_raw(&r.front(), r.size());
return *this;
}
query_c& p(long long v)
{
std::stringstream ss;
ss << v;
p_raw(ss.str());
return *this;
}
drizzle_return_t execute(result_c& result)
{
return con_.query(result, read());
}
result_c execute()
{
return con_.query(read());
}
std::string read() const
{
return out_ + in_;
}
private:
connection_c& con_;
std::string in_;
std::string out_;
};
template<class T>
const char* get_conf(const T& c, const std::string& v)
{
typename T::const_iterator i = c.find(v);
return i == c.end() ? NULL : i->second.c_str();
}
void connection_c::read_conf_files()
{
using namespace std;
vector<string> conf_files;
#ifdef WIN32
{
boost::array<char, MAX_PATH> d;
GetWindowsDirectoryA(d.data(), d.size());
conf_files.push_back(string(d.data()) + "/my.cnf");
conf_files.push_back(string(d.data()) + "/drizzle.cnf");
conf_files.push_back(string(d.data()) + "/drizzle.conf");
}
#else
conf_files.push_back("/etc/mysql/my.cnf");
conf_files.push_back("/etc/drizzle/drizzle.cnf");
conf_files.push_back("/etc/drizzle/drizzle.conf");
#endif
if (const char* d = getenv("HOME"))
{
conf_files.push_back(string(d) + "/.my.cnf");
conf_files.push_back(string(d) + "/.drizzle.conf");
}
map<string, string> conf;
BOOST_FOREACH(string& it, conf_files)
{
ifstream is(it.c_str());
bool client_section = false;
for (string s; getline(is, s); )
{
size_t i = s.find('#');
if (i != string::npos)
s.erase(i);
boost::trim(s);
if (boost::starts_with(s, "["))
{
client_section = s == "[client]";
continue;
}
else if (!client_section)
continue;
i = s.find('=');
if (i != string::npos)
conf[boost::trim_copy(s.substr(0, i))] = boost::trim_copy(s.substr(i + 1));
}
}
if (conf.count("host") || conf.count("port"))
set_tcp(get_conf(conf, "host"), atoi(get_conf(conf, "port")));
if (conf.count("user") || conf.count("password"))
set_auth(get_conf(conf, "user"), get_conf(conf, "password"));
}
}

56
utils/mysqlcl_idb/libdrizzle-2.0/limits.h
View File

@ -1,56 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2011 Brian Aker (brian@tangent.org)
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
#define DRIZZLE_MAX_BUFFER_SIZE 32768
#define DRIZZLE_MAX_CATALOG_SIZE 128
#define DRIZZLE_MAX_COLUMN_NAME_SIZE 2048
#define DRIZZLE_MAX_DB_SIZE DRIZZLE_MAX_SCHEMA_SIZE
#define DRIZZLE_MAX_DEFAULT_VALUE_SIZE 2048
#define DRIZZLE_MAX_ERROR_SIZE 2048
#define DRIZZLE_MAX_INFO_SIZE 2048
#define DRIZZLE_MAX_PACKET_SIZE UINT32_MAX
#define DRIZZLE_MAX_PASSWORD_SIZE 32
#define DRIZZLE_MAX_SCHEMA_SIZE 64
#define DRIZZLE_MAX_SCRAMBLE_SIZE 20
#define DRIZZLE_MAX_SERVER_EXTRA_SIZE 32
#define DRIZZLE_MAX_SERVER_VERSION_SIZE 32
#define DRIZZLE_MAX_SQLSTATE_SIZE 5
#define DRIZZLE_MAX_TABLE_SIZE 128
#define DRIZZLE_MAX_USER_SIZE 64

93
utils/mysqlcl_idb/libdrizzle-2.0/pack.h
View File

@ -1,93 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Packing Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_pack Packing Declarations
*
* These functions are used internally to pack various parts of the protocol.
* Not all functions are defined in pack.c, they are in the most appropriate
* source file (for example, handshake.c for drizzle_pack_client_handshake).
* @{
*/
/**
* Pack length-encoded number.
*/
DRIZZLE_API
uint8_t *drizzle_pack_length(uint64_t number, uint8_t *ptr);
/**
* Unpack length-encoded number.
*/
DRIZZLE_API
uint64_t drizzle_unpack_length(drizzle_con_st *con, drizzle_return_t *ret_ptr);
/**
* Pack length-encoded string.
*/
DRIZZLE_API
uint8_t *drizzle_pack_string(char *string, uint8_t *ptr);
/**
* Unpack length-encoded string.
*/
DRIZZLE_API
drizzle_return_t drizzle_unpack_string(drizzle_con_st *con, char *buffer,
uint64_t max_size);
/**
* Pack user, scramble, and db.
*/
DRIZZLE_API
uint8_t *drizzle_pack_auth(drizzle_con_st *con, uint8_t *ptr,
drizzle_return_t *ret_ptr);
/** @} */
#ifdef __cplusplus
}
#endif

239
utils/mysqlcl_idb/libdrizzle-2.0/query.h
View File

@ -1,239 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Query Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_query Query Declarations
*
* @ingroup drizzle_client_interface
* These functions are used to issue queries on a connection. Single queries are
* made using the drizzle_query function, or you can queue multiple queries and
* run them concurrently using the other query functions.
* @{
*/
/**
* Send query to server. A \ref drizzle_result_st will be created for the
* results.
*
* @param[in] con connection to use to send the query.
* @param[in,out] result pointer to an unused structure that will be used for
* the results, or NULL to allocate a new structure.
* @param[in] query query string to send.
* @param[in] size length of the query string in bytes.
* @param[out] ret_ptr pointer to the result code.
* @return result, a pointer to the newly allocated result structure, or NULL
* if the allocation failed.
*/
DRIZZLE_API
drizzle_result_st *drizzle_query(drizzle_con_st *con, drizzle_result_st *result,
const char *query, size_t size,
drizzle_return_t *ret_ptr);
/**
* Send query to server, using strlen to get the size of query buffer..
*/
DRIZZLE_API
drizzle_result_st *drizzle_query_str(drizzle_con_st *con,
drizzle_result_st *result,
const char *query,
drizzle_return_t *ret_ptr);
/**
* Send query incrementally.
*/
DRIZZLE_API
drizzle_result_st *drizzle_query_inc(drizzle_con_st *con,
drizzle_result_st *result,
const char *query, size_t size,
size_t total, drizzle_return_t *ret_ptr);
/**
* Add a query to be run concurrently.
*/
DRIZZLE_API
drizzle_query_st *drizzle_query_add(drizzle_st *drizzle,
drizzle_query_st *query,
drizzle_con_st *con,
drizzle_result_st *result,
const char *query_string, size_t size,
drizzle_query_options_t options,
void *context);
/**
* Initialize a query structure.
*/
DRIZZLE_API
drizzle_query_st *drizzle_query_create(drizzle_st *drizzle,
drizzle_query_st *query);
/**
* Free a query structure.
*/
DRIZZLE_API
void drizzle_query_free(drizzle_query_st *query);
/**
* Free a query structure.
*/
DRIZZLE_API
void drizzle_query_free_all(drizzle_st *drizzle);
/**
* Get connection struct for a query.
*/
DRIZZLE_API
drizzle_con_st *drizzle_query_con(drizzle_query_st *query);
/**
* Set connection struct for a query.
*/
DRIZZLE_API
void drizzle_query_set_con(drizzle_query_st *query, drizzle_con_st *con);
/**
* Get result struct for a query.
*/
DRIZZLE_API
drizzle_result_st *drizzle_query_result(drizzle_query_st *query);
/**
* Set result struct for a query.
*/
DRIZZLE_API
void drizzle_query_set_result(drizzle_query_st *query,
drizzle_result_st *result);
/**
* Get query string for a query.
*/
DRIZZLE_API
char *drizzle_query_string(drizzle_query_st *query, size_t *size);
/**
* Set query string for a query.
*/
DRIZZLE_API
void drizzle_query_set_string(drizzle_query_st *query, const char *string,
size_t size);
/**
* Get options for a query.
*/
DRIZZLE_API
int drizzle_query_options(drizzle_query_st *);
/**
* Set options for a query.
*/
DRIZZLE_API
void drizzle_query_set_options(drizzle_query_st *, int);
/**
* Add options for a query.
*/
DRIZZLE_API
void drizzle_query_add_options(drizzle_query_st *, int);
/**
* Remove options for a query.
*/
DRIZZLE_API
void drizzle_query_remove_options(drizzle_query_st *, int);
/**
* Get application context for a query.
*/
DRIZZLE_API
void *drizzle_query_context(drizzle_query_st *query);
/**
* Set application context for a query.
*/
DRIZZLE_API
void drizzle_query_set_context(drizzle_query_st *query, void *context);
/**
* Set callback function when the context pointer should be freed.
*/
DRIZZLE_API
void drizzle_query_set_context_free_fn(drizzle_query_st *query,
drizzle_query_context_free_fn *function);
/**
* Run queries concurrently, returning when one is complete.
*/
DRIZZLE_API
drizzle_query_st *drizzle_query_run(drizzle_st *drizzle,
drizzle_return_t *ret_ptr);
/**
* Run queries until they are all complete. Returns \ref DRIZZLE_RETURN_OK if
* all queries complete, even if some return errors. This returns immediately
* if some other error occurs, leaving some queries unprocessed. You must call
* drizzle_result_error_code() to check if each query succeeded.
*/
DRIZZLE_API
drizzle_return_t drizzle_query_run_all(drizzle_st *drizzle);
/*
* Escape a string or encode a string in hexadecimal. The return value is the
* size of the output string in to.
*/
DRIZZLE_API
ssize_t drizzle_escape_string(char *to, size_t max_to_size, const char *from, size_t from_size);
DRIZZLE_API
size_t drizzle_hex_string(char *to, const char *from, size_t from_size);
DRIZZLE_API
void drizzle_mysql_password_hash(char *to, const char *from, size_t from_size);
/** @} */
#ifdef __cplusplus
}
#endif

155
utils/mysqlcl_idb/libdrizzle-2.0/result.h
View File

@ -1,155 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Result Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_result Result Declarations
* @ingroup drizzle_client_interface
* @ingroup drizzle_server_interface
*
* These are core result functions used by both clients and servers.
* @{
*/
/**
* Initialize a result structure.
*/
DRIZZLE_API
drizzle_result_st *drizzle_result_create(drizzle_con_st *con);
drizzle_result_st *drizzle_result_create_with(drizzle_con_st *con,
drizzle_result_st *result);
/**
* Clone a connection structure.
*/
DRIZZLE_API
drizzle_result_st *drizzle_result_clone(drizzle_con_st *con,
drizzle_result_st *source);
/**
* Free a result structure.
*/
DRIZZLE_API
void drizzle_result_free(drizzle_result_st *result);
/**
* Free all result structures.
*/
DRIZZLE_API
void drizzle_result_free_all(drizzle_con_st *con);
/**
* Get the drizzle_con_st struct that the result belongs to.
*/
DRIZZLE_API
drizzle_con_st *drizzle_result_drizzle_con(drizzle_result_st *result);
/**
* Get EOF flag for a result.
*/
DRIZZLE_API
bool drizzle_result_eof(drizzle_result_st *result);
/**
* Get information string for a result.
*/
DRIZZLE_API
const char *drizzle_result_info(drizzle_result_st *result);
/**
* Get error string for a result.
*/
DRIZZLE_API
const char *drizzle_result_error(drizzle_result_st *result);
/**
* Get server defined error code for a result.
*/
DRIZZLE_API
uint16_t drizzle_result_error_code(drizzle_result_st *result);
/**
* Get SQL state code for a result.
*/
DRIZZLE_API
const char *drizzle_result_sqlstate(drizzle_result_st *result);
/**
* Get the number of warnings encounted during a command.
*/
DRIZZLE_API
uint16_t drizzle_result_warning_count(drizzle_result_st *result);
/**
* Get inet ID of the last command, if any.
*/
DRIZZLE_API
uint64_t drizzle_result_insert_id(drizzle_result_st *result);
/**
* Get the number of affected rows during the command.
*/
DRIZZLE_API
uint64_t drizzle_result_affected_rows(drizzle_result_st *result);
/**
* Get the number of columns in a result set.
*/
DRIZZLE_API
uint16_t drizzle_result_column_count(drizzle_result_st *result);
/**
* Get the number of rows returned for the command.
*/
DRIZZLE_API
uint64_t drizzle_result_row_count(drizzle_result_st *result);
/** @} */
#ifdef __cplusplus
}
#endif

80
utils/mysqlcl_idb/libdrizzle-2.0/result_client.h
View File

@ -1,80 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Result Declarations for Clients
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_result_client Result Declarations for Clients
* @ingroup drizzle_client_interface
*
* These functions read or buffer the result for a client command.
* @{
*/
/**
* Read result packet.
*/
DRIZZLE_API
drizzle_result_st *drizzle_result_read(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_return_t *ret_ptr);
/**
* Buffer all data for a result.
*/
DRIZZLE_API
drizzle_return_t drizzle_result_buffer(drizzle_result_st *result);
/**
* Get result row packet size.
*/
DRIZZLE_API
size_t drizzle_result_row_size(drizzle_result_st *result);
/** @} */
#ifdef __cplusplus
}
#endif

141
utils/mysqlcl_idb/libdrizzle-2.0/result_server.h
View File

@ -1,141 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Result Declarations for Servers
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_result_server Result Declarations for Servers
* @ingroup drizzle_server_interface
*
* These functions allow you to send result packets over a connection.
* @{
*/
/**
* Write result packet.
*/
DRIZZLE_API
drizzle_return_t drizzle_result_write(drizzle_con_st *con,
drizzle_result_st *result, bool flush);
/**
* Set result row packet size.
*/
DRIZZLE_API
void drizzle_result_set_row_size(drizzle_result_st *result, size_t size);
/**
* Set result row packet size from field and size arrays.
*/
DRIZZLE_API
void drizzle_result_calc_row_size(drizzle_result_st *result,
const drizzle_field_t *field,
const size_t *size);
/**
* Set information string for a result.
*/
DRIZZLE_API
void drizzle_result_set_eof(drizzle_result_st *result, bool eof);
/**
* Set information string for a result.
*/
DRIZZLE_API
void drizzle_result_set_info(drizzle_result_st *result, const char *info);
/**
* Set error string for a result.
*/
DRIZZLE_API
void drizzle_result_set_error(drizzle_result_st *result, const char *error);
/**
* Set server defined error code for a result.
*/
DRIZZLE_API
void drizzle_result_set_error_code(drizzle_result_st *result,
uint16_t error_code);
/**
* Set SQL state code for a result.
*/
DRIZZLE_API
void drizzle_result_set_sqlstate(drizzle_result_st *result,
const char *sqlstate);
/**
* Set the number of warnings encounted during a command.
*/
DRIZZLE_API
void drizzle_result_set_warning_count(drizzle_result_st *result,
uint16_t warning_count);
/**
* Set inet ID of the last command, if any.
*/
DRIZZLE_API
void drizzle_result_set_insert_id(drizzle_result_st *result,
uint64_t insert_id);
/**
* Set the number of affected rows during the command.
*/
DRIZZLE_API
void drizzle_result_set_affected_rows(drizzle_result_st *result,
uint64_t affected_rows);
/**
* Set the number of fields in a result set.
*/
DRIZZLE_API
void drizzle_result_set_column_count(drizzle_result_st *result,
uint16_t column_count);
/** @} */
#ifdef __cplusplus
}
#endif

78
utils/mysqlcl_idb/libdrizzle-2.0/return.h
View File

@ -1,78 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2011 Brian Aker (brian@tangent.org)
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* Return codes.
*/
enum drizzle_return_t
{
DRIZZLE_RETURN_OK,
DRIZZLE_RETURN_IO_WAIT,
DRIZZLE_RETURN_PAUSE,
DRIZZLE_RETURN_ROW_BREAK,
DRIZZLE_RETURN_MEMORY,
DRIZZLE_RETURN_ERRNO,
DRIZZLE_RETURN_INTERNAL_ERROR,
DRIZZLE_RETURN_GETADDRINFO,
DRIZZLE_RETURN_NOT_READY,
DRIZZLE_RETURN_BAD_PACKET_NUMBER,
DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET,
DRIZZLE_RETURN_BAD_PACKET,
DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED,
DRIZZLE_RETURN_UNEXPECTED_DATA,
DRIZZLE_RETURN_NO_SCRAMBLE,
DRIZZLE_RETURN_AUTH_FAILED,
DRIZZLE_RETURN_NULL_SIZE,
DRIZZLE_RETURN_ERROR_CODE,
DRIZZLE_RETURN_TOO_MANY_COLUMNS,
DRIZZLE_RETURN_ROW_END,
DRIZZLE_RETURN_LOST_CONNECTION,
DRIZZLE_RETURN_COULD_NOT_CONNECT,
DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS,
DRIZZLE_RETURN_HANDSHAKE_FAILED,
DRIZZLE_RETURN_TIMEOUT,
DRIZZLE_RETURN_INVALID_ARGUMENT,
DRIZZLE_RETURN_MAX /* Always add new codes to the end before this one. */
};
#ifndef __cplusplus
typedef enum drizzle_return_t drizzle_return_t
#endif

130
utils/mysqlcl_idb/libdrizzle-2.0/row_client.h
View File

@ -1,130 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Row Declarations for Clients
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_row_client Row Declarations for Clients
* @ingroup drizzle_client_interface
*
* These functions allow you to access rows in a result set. If the result is
* unbuffered, you can read and buffer rows one at a time. If the rows are
* buffered in the result, the drizzle_row_next() and related functions can be
* used.
* @{
*/
/**
* Get next row number for unbuffered results. Use the drizzle_field* functions
* to read individual fields after this function succeeds.
*
* @param[in,out] result pointer to the structure to read from.
* @param[out] ret_ptr Standard libdrizzle return value. May be set to
* DRIZZLE_RESULT_ERROR_CODE if the server return an error, such as a
* deadlock.
* @return the row id if there is a valid row, or 0 if there are no more rows or an error.
*/
DRIZZLE_API
uint64_t drizzle_row_read(drizzle_result_st *result, drizzle_return_t *ret_ptr);
/**
* Read and buffer one row. The returned row must be freed by the caller with
* drizzle_row_free().
*
* @param[in,out] result pointer to the result structure to read from.
* @param[out] ret_pointer Standard drizzle return value.
* @return the row that was read, or NULL if there are no more rows.
*/
DRIZZLE_API
drizzle_row_t drizzle_row_buffer(drizzle_result_st *result,
drizzle_return_t *ret_ptr);
/**
* Free a row that was buffered with drizzle_row_buffer().
*/
DRIZZLE_API
void drizzle_row_free(drizzle_result_st *result, drizzle_row_t row);
/**
* Get an array of all field sizes for buffered rows.
*/
DRIZZLE_API
size_t *drizzle_row_field_sizes(drizzle_result_st *result);
/**
* Get next buffered row from a fully buffered result.
*/
DRIZZLE_API
drizzle_row_t drizzle_row_next(drizzle_result_st *result);
/**
* Get previous buffered row from a fully buffered result.
*/
DRIZZLE_API
drizzle_row_t drizzle_row_prev(drizzle_result_st *result);
/**
* Seek to the given buffered row in a fully buffered result.
*/
DRIZZLE_API
void drizzle_row_seek(drizzle_result_st *result, uint64_t row);
/**
* Get the given buffered row from a fully buffered result.
*/
DRIZZLE_API
drizzle_row_t drizzle_row_index(drizzle_result_st *result, uint64_t row);
/**
* Get current row number.
*/
DRIZZLE_API
uint64_t drizzle_row_current(drizzle_result_st *result);
/** @} */
#ifdef __cplusplus
}
#endif

66
utils/mysqlcl_idb/libdrizzle-2.0/row_server.h
View File

@ -1,66 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Row Declarations for Servers
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_row_server Row Declarations for Servers
* @ingroup drizzle_server_interface
*
* These functions allow you to send row information over a connection.
* @{
*/
/**
* Write next row.
*/
DRIZZLE_API
drizzle_return_t drizzle_row_write(drizzle_result_st *result);
/** @} */
#ifdef __cplusplus
}
#endif

44
utils/mysqlcl_idb/libdrizzle-2.0/sha1.h
View File

@ -1,44 +0,0 @@
#pragma once
/**
* @file
* @brief SHA1 Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup sha1 SHA-1 in C
*
* Copyright (C) 2010 nobody (this is public domain)
*
* This file is based on public domain code.
* Initial source code is in the public domain,
* so clarified by Steve Reid <steve@edmweb.com>
*
* @{
*/
#define SHA1_BLOCK_LENGTH 64
#define SHA1_DIGEST_LENGTH 20
#define SHA1_DIGEST_STRING_LENGTH (SHA1_DIGEST_LENGTH * 2 + 1)
typedef struct {
uint32_t state[5];
uint64_t count;
uint8_t buffer[SHA1_BLOCK_LENGTH];
} SHA1_CTX;
void SHA1Init(SHA1_CTX *);
void SHA1Pad(SHA1_CTX *);
void SHA1Transform(uint32_t [5], const uint8_t [SHA1_BLOCK_LENGTH]);
void SHA1Update(SHA1_CTX *, const uint8_t *, size_t);
void SHA1Final(uint8_t [SHA1_DIGEST_LENGTH], SHA1_CTX *);
/** @} */
#ifdef __cplusplus
}
#endif

108
utils/mysqlcl_idb/libdrizzle-2.0/state.h
View File

@ -1,108 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief State Machine Declarations
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup drizzle_state State Machine Declarations
*
* These functions are used in the protocol parsing state machine. Not all
* functions are defined in state.c, they are in the most appropriate source
* file (for example, handshake.c for drizzle_state_handshake_server_read).
* @{
*/
/**
* Main state loop for connections.
*
* @param[in] con Connection structure previously initialized with
* drizzle_con_create(), drizzle_con_clone(), or related functions.
* @return Standard drizzle return value.
*/
drizzle_return_t drizzle_state_loop(drizzle_con_st *con);
/* Functions in state.c */
drizzle_return_t drizzle_state_packet_read(drizzle_con_st *con);
/* Functions in conn.c */
drizzle_return_t drizzle_state_addrinfo(drizzle_con_st *con);
drizzle_return_t drizzle_state_connect(drizzle_con_st *con);
drizzle_return_t drizzle_state_connecting(drizzle_con_st *con);
drizzle_return_t drizzle_state_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_write(drizzle_con_st *con);
drizzle_return_t drizzle_state_listen(drizzle_con_st *con);
/* Functions in handshake.c */
drizzle_return_t drizzle_state_handshake_server_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_handshake_server_write(drizzle_con_st *con);
drizzle_return_t drizzle_state_handshake_client_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_handshake_client_write(drizzle_con_st *con);
drizzle_return_t drizzle_state_handshake_result_read(drizzle_con_st *con);
/* Functions in command.c */
drizzle_return_t drizzle_state_command_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_command_write(drizzle_con_st *con);
/* Functions in result.c */
drizzle_return_t drizzle_state_result_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_result_write(drizzle_con_st *con);
/* Functions in column.c */
drizzle_return_t drizzle_state_column_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_column_write(drizzle_con_st *con);
/* Functions in row.c */
drizzle_return_t drizzle_state_row_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_row_write(drizzle_con_st *con);
/* Functions in field.c */
drizzle_return_t drizzle_state_field_read(drizzle_con_st *con);
drizzle_return_t drizzle_state_field_write(drizzle_con_st *con);
/** @} */
#ifdef __cplusplus
}
#endif

403
utils/mysqlcl_idb/libdrizzle-2.0/structs.h
View File

@ -1,403 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* @file
* @brief Struct Definitions
*/
#include <sys/types.h>
#ifndef NI_MAXHOST
# define NI_MAXHOST 1025
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __cplusplus
struct drizzle_st;
struct drizzle_con_tcp_st;
struct drizzle_con_uds_st;
struct drizzle_con_st;
struct drizzle_query_st;
struct drizzle_result_st;
struct drizzle_column_st;
#else
/**
* @ingroup drizzle
*/
class drizzle_st
{
public:
uint16_t error_code;
struct options_t {
bool is_allocated;
bool is_non_blocking;
bool is_free_objects;
bool is_assert_dangling;
options_t() :
is_allocated(false),
is_non_blocking(false),
is_free_objects(false),
is_assert_dangling(false)
{ }
} options;
drizzle_verbose_t verbose;
uint32_t con_count;
uint32_t pfds_size;
uint32_t query_count;
uint32_t query_new;
uint32_t query_running;
int last_errno;
int timeout;
drizzle_con_st *con_list;
void *context;
drizzle_context_free_fn *context_free_fn;
drizzle_event_watch_fn *event_watch_fn;
void *event_watch_context;
drizzle_log_fn *log_fn;
void *log_context;
struct pollfd *pfds;
drizzle_query_st *query_list;
char sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE + 1];
char last_error[DRIZZLE_MAX_ERROR_SIZE];
drizzle_st() :
error_code(0),
options(),
verbose(DRIZZLE_VERBOSE_ERROR),
con_count(0),
pfds_size(0),
query_count(0),
query_new(0),
query_running(0),
last_errno(0),
timeout(-1),
con_list(NULL),
context(NULL),
context_free_fn(NULL),
event_watch_fn(NULL),
event_watch_context(NULL),
log_fn(NULL),
log_context(NULL),
pfds(NULL),
query_list(NULL)
{ }
};
/**
* @ingroup drizzle_con
*/
class drizzle_con_tcp_st
{
public:
in_port_t port;
struct addrinfo *addrinfo;
char *host;
char host_buffer[NI_MAXHOST];
};
/**
* @ingroup drizzle_con
*/
class drizzle_con_uds_st
{
public:
struct addrinfo addrinfo;
struct sockaddr_un sockaddr;
};
/**
* @ingroup drizzle_con
*/
class drizzle_con_st
{
public:
uint8_t packet_number;
uint8_t protocol_version;
uint8_t state_current;
short events;
short revents;
int capabilities;
drizzle_charset_t charset;
drizzle_command_t command;
struct option_t {
bool is_allocated;
option_t() :
is_allocated(false)
{ }
} _options;
int options;
drizzle_con_socket_t socket_type;
drizzle_con_status_t status;
uint32_t max_packet_size;
uint32_t result_count;
uint32_t thread_id;
int backlog;
int fd;
size_t buffer_size;
size_t command_offset;
size_t command_size;
size_t command_total;
size_t packet_size;
struct addrinfo *addrinfo_next;
uint8_t *buffer_ptr;
uint8_t *command_buffer;
uint8_t *command_data;
void *context;
drizzle_con_context_free_fn *context_free_fn;
drizzle_st *drizzle;
drizzle_con_st *next;
drizzle_con_st *prev;
drizzle_query_st *query;
drizzle_result_st *result;
drizzle_result_st *result_list;
uint8_t *scramble;
union
{
drizzle_con_tcp_st tcp;
drizzle_con_uds_st uds;
} socket;
uint8_t buffer[DRIZZLE_MAX_BUFFER_SIZE];
char schema[DRIZZLE_MAX_DB_SIZE];
char password[DRIZZLE_MAX_PASSWORD_SIZE];
uint8_t scramble_buffer[DRIZZLE_MAX_SCRAMBLE_SIZE];
char server_version[DRIZZLE_MAX_SERVER_VERSION_SIZE];
char server_extra[DRIZZLE_MAX_SERVER_EXTRA_SIZE];
drizzle_state_fn *state_stack[DRIZZLE_STATE_STACK_SIZE];
char user[DRIZZLE_MAX_USER_SIZE];
drizzle_con_st() :
packet_number(0),
protocol_version(0),
state_current(0),
events(0),
revents(0),
capabilities(DRIZZLE_CAPABILITIES_NONE),
options(DRIZZLE_CON_NONE),
max_packet_size(0),
result_count(0),
thread_id(0),
backlog(0),
fd(0),
buffer_size(0),
command_offset(0),
command_size(0),
command_total(0),
packet_size(0),
addrinfo_next(NULL),
buffer_ptr(NULL),
command_buffer(NULL),
command_data(NULL),
context(NULL),
context_free_fn(NULL),
drizzle(NULL),
next(NULL),
prev(NULL),
query(NULL),
result(NULL),
result_list(NULL),
scramble(NULL)
{ }
};
/**
* @ingroup drizzle_query
*/
class drizzle_query_st
{
private:
public:
drizzle_st *drizzle;
drizzle_query_st *next;
drizzle_query_st *prev;
struct option_t {
bool is_allocated;
option_t() :
is_allocated(false)
{ }
} options;
drizzle_query_state_t state;
drizzle_con_st *con;
drizzle_result_st *result;
const char *string;
size_t size;
void *context;
drizzle_query_context_free_fn *context_free_fn;
drizzle_query_st() :
drizzle(NULL),
next(NULL),
prev(NULL),
con(NULL),
result(NULL),
string(NULL),
size(0),
context(NULL),
context_free_fn(NULL)
{ }
};
/**
* @ingroup drizzle_result
*/
class drizzle_result_st
{
public:
drizzle_con_st *con;
drizzle_result_st *next;
drizzle_result_st *prev;
struct option_t {
bool is_allocated;
option_t() :
is_allocated(false)
{ }
} _options;
int options;
char info[DRIZZLE_MAX_INFO_SIZE];
uint16_t error_code;
char sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE + 1];
uint64_t insert_id;
uint16_t warning_count;
uint64_t affected_rows;
uint16_t column_count;
uint16_t column_current;
drizzle_column_st *column_list;
drizzle_column_st *column;
drizzle_column_st *column_buffer;
uint64_t row_count;
uint64_t row_current;
uint16_t field_current;
size_t field_total;
size_t field_offset;
size_t field_size;
drizzle_field_t field;
drizzle_field_t field_buffer;
uint64_t row_list_size;
drizzle_row_t row;
drizzle_row_list_t *row_list;
size_t *field_sizes;
drizzle_field_sizes_list_t *field_sizes_list;
drizzle_result_st() :
con(NULL),
next(NULL),
prev(NULL),
options(DRIZZLE_RESULT_NONE),
error_code(0),
insert_id(0),
warning_count(0),
affected_rows(0),
column_count(0),
column_current(0),
column_list(NULL),
column(NULL),
column_buffer(NULL),
row_count(0),
row_current(0),
field_current(0),
field_total(0),
field_offset(0),
field_size(0),
row_list_size(0),
row_list(NULL),
field_sizes(NULL),
field_sizes_list(NULL)
{ }
};
/**
* @ingroup drizzle_column
*/
class drizzle_column_st
{
public:
drizzle_result_st *result;
drizzle_column_st *next;
drizzle_column_st *prev;
struct options_t {
bool is_allocated;
options_t() :
is_allocated(false)
{ }
} options;
char catalog[DRIZZLE_MAX_CATALOG_SIZE];
char schema[DRIZZLE_MAX_DB_SIZE];
char table[DRIZZLE_MAX_TABLE_SIZE];
char orig_table[DRIZZLE_MAX_TABLE_SIZE];
char name[DRIZZLE_MAX_COLUMN_NAME_SIZE];
char orig_name[DRIZZLE_MAX_COLUMN_NAME_SIZE];
drizzle_charset_t charset;
uint32_t size;
size_t max_size;
drizzle_column_type_t type;
int flags;
uint8_t decimals;
uint8_t default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE];
size_t default_value_size;
drizzle_column_st() :
result(NULL),
next(NULL),
prev(NULL),
size(0),
max_size(0),
flags(DRIZZLE_COLUMN_FLAGS_NONE),
decimals(0),
default_value_size(0)
{ }
};
#endif
#ifdef __cplusplus
}
#endif

58
utils/mysqlcl_idb/libdrizzle-2.0/verbose.h
View File

@ -1,58 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2011 Brian Aker (brian@tangent.org)
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
/**
* Verbosity levels.
*/
enum drizzle_verbose_t
{
DRIZZLE_VERBOSE_NEVER,
DRIZZLE_VERBOSE_FATAL,
DRIZZLE_VERBOSE_ERROR,
DRIZZLE_VERBOSE_INFO,
DRIZZLE_VERBOSE_DEBUG,
DRIZZLE_VERBOSE_CRAZY,
DRIZZLE_VERBOSE_MAX
};
#ifndef __cplusplus
typedef enum drizzle_verbose_t drizzle_verbose_t;
#endif

78
utils/mysqlcl_idb/libdrizzle-2.0/visibility.h
View File

@ -1,78 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
* Implementation drawn from visibility.texi in gnulib.
*/
#pragma once
/**
* @file
* @brief Visibility Control Macros
*/
/**
*
* DRIZZLE_API is used for the public API symbols. It either DLL imports or
* DLL exports (or does nothing for static build).
*
* DRIZZLE_LOCAL is used for non-api symbols.
*/
#if defined(_WIN32)
# define DRIZZLE_API
# define DRIZZLE_LOCAL
#else
#if defined(BUILDING_LIBDRIZZLE)
# if defined(HAVE_VISIBILITY)
# define DRIZZLE_API __attribute__ ((visibility("default")))
# define DRIZZLE_LOCAL __attribute__ ((visibility("hidden")))
# elif defined (__SUNPRO_C) && (__SUNPRO_C >= 0x550)
# define DRIZZLE_API __global
# define DRIZZLE_API __hidden
# elif defined(_MSC_VER)
# define DRIZZLE_API extern __declspec(dllexport)
# define DRIZZLE_LOCAL
# endif /* defined(HAVE_VISIBILITY) */
#else /* defined(BUILDING_LIBDRIZZLE) */
# if defined(_MSC_VER)
# define DRIZZLE_API extern __declspec(dllimport)
# define DRIZZLE_LOCAL
# else
# define DRIZZLE_API
# define DRIZZLE_LOCAL
# endif /* defined(_MSC_VER) */
#endif /* defined(BUILDING_LIBDRIZZLE) */
#endif /* _WIN32 */

235
utils/mysqlcl_idb/libmysqlcl_idb.vcxproj
View File

@ -1,235 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="EnterpriseRelease|Win32">
<Configuration>EnterpriseRelease</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="EnterpriseRelease|x64">
<Configuration>EnterpriseRelease</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{0BBAEACB-3336-4406-ACFB-255669A3B9CF}</ProjectGuid>
<RootNamespace>libmysqlcl_idb</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>11.0.50727.1</_ProjectFileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>$(SolutionDir)..\..\$(PlatformName)\$(ConfigurationName)\</OutDir>
<IntDir>$(SolutionDir)..\..\obj\$(ProjectName)\$(PlatformName)\$(ConfigurationName)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>$(SolutionDir)..\..\$(Platform)\$(Configuration)\</OutDir>
<IntDir>$(SolutionDir)..\..\obj\$(ProjectName)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>$(SolutionDir)..\..\$(PlatformName)\$(ConfigurationName)\</OutDir>
<IntDir>$(SolutionDir)..\..\obj\$(ProjectName)\$(PlatformName)\$(ConfigurationName)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<OutDir>$(SolutionDir)..\..\$(Platform)\$(Configuration)\</OutDir>
<IntDir>$(SolutionDir)..\..\obj\$(ProjectName)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|Win32'">
<OutDir>$(SolutionDir)..\..\$(PlatformName)\$(ConfigurationName)\</OutDir>
<IntDir>$(SolutionDir)..\..\obj\$(ProjectName)\$(PlatformName)\$(ConfigurationName)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|x64'">
<OutDir>$(SolutionDir)..\..\$(Platform)\$(Configuration)\</OutDir>
<IntDir>$(SolutionDir)..\..\obj\$(ProjectName)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>$(SolutionDir)..\utils\mysqlcl_idb;$(SolutionDir)..\utils\configcpp;$(SolutionDir)..\utils\winport;$(SolutionDir)..\..\boost_1_54_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>$(SolutionDir)..\utils\mysqlcl_idb;$(SolutionDir)..\utils\configcpp;$(SolutionDir)..\utils\winport;$(SolutionDir)..\..\boost_1_54_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>$(SolutionDir)..\utils\mysqlcl_idb;$(SolutionDir)..\utils\configcpp;$(SolutionDir)..\utils\winport;$(SolutionDir)..\..\boost_1_54_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>$(SolutionDir)..\utils\mysqlcl_idb;$(SolutionDir)..\utils\configcpp;$(SolutionDir)..\utils\winport;$(SolutionDir)..\..\boost_1_54_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|Win32'">
<ClCompile>
<AdditionalIncludeDirectories>$(SolutionDir)..\utils\mysqlcl_idb;$(SolutionDir)..\utils\configcpp;$(SolutionDir)..\utils\winport;$(SolutionDir)..\..\boost_1_54_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='EnterpriseRelease|x64'">
<ClCompile>
<AdditionalIncludeDirectories>$(SolutionDir)..\utils\mysqlcl_idb;$(SolutionDir)..\utils\configcpp;$(SolutionDir)..\utils\winport;$(SolutionDir)..\..\boost_1_54_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
<BufferSecurityCheck>false</BufferSecurityCheck>
</ClCompile>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="column.cc" />
<ClCompile Include="command.cc" />
<ClCompile Include="conn.cc" />
<ClCompile Include="conn_uds.cc" />
<ClCompile Include="drizzle.cc" />
<ClCompile Include="field.cc" />
<ClCompile Include="handshake.cc" />
<ClCompile Include="pack.cc" />
<ClCompile Include="query.cc" />
<ClCompile Include="result.cc" />
<ClCompile Include="row.cc" />
<ClCompile Include="sha1.cc" />
<ClCompile Include="state.cc" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="libdrizzle-2.0\column.h" />
<ClInclude Include="libdrizzle-2.0\column_client.h" />
<ClInclude Include="libdrizzle-2.0\column_server.h" />
<ClInclude Include="libdrizzle-2.0\command.h" />
<ClInclude Include="libdrizzle-2.0\command_client.h" />
<ClInclude Include="libdrizzle-2.0\command_server.h" />
<ClInclude Include="libdrizzle-2.0\common.h" />
<ClInclude Include="libdrizzle-2.0\conn.h" />
<ClInclude Include="libdrizzle-2.0\conn_client.h" />
<ClInclude Include="libdrizzle-2.0\conn_local.h" />
<ClInclude Include="libdrizzle-2.0\conn_server.h" />
<ClInclude Include="libdrizzle-2.0\constants.h" />
<ClInclude Include="libdrizzle-2.0\deprecated_enum.h" />
<ClInclude Include="libdrizzle-2.0\drizzle.h" />
<ClInclude Include="libdrizzle-2.0\drizzle_client.h" />
<ClInclude Include="libdrizzle-2.0\drizzle_local.h" />
<ClInclude Include="libdrizzle-2.0\drizzle_server.h" />
<ClInclude Include="libdrizzle-2.0\field_client.h" />
<ClInclude Include="libdrizzle-2.0\field_server.h" />
<ClInclude Include="libdrizzle-2.0\handshake_client.h" />
<ClInclude Include="libdrizzle-2.0\handshake_server.h" />
<ClInclude Include="libdrizzle-2.0\libdrizzle.h" />
<ClInclude Include="libdrizzle-2.0\libdrizzle.hpp" />
<ClInclude Include="libdrizzle-2.0\limits.h" />
<ClInclude Include="libdrizzle-2.0\pack.h" />
<ClInclude Include="libdrizzle-2.0\query.h" />
<ClInclude Include="libdrizzle-2.0\result.h" />
<ClInclude Include="libdrizzle-2.0\result_client.h" />
<ClInclude Include="libdrizzle-2.0\result_server.h" />
<ClInclude Include="libdrizzle-2.0\return.h" />
<ClInclude Include="libdrizzle-2.0\row_client.h" />
<ClInclude Include="libdrizzle-2.0\row_server.h" />
<ClInclude Include="libdrizzle-2.0\sha1.h" />
<ClInclude Include="libdrizzle-2.0\state.h" />
<ClInclude Include="libdrizzle-2.0\structs.h" />
<ClInclude Include="libdrizzle-2.0\verbose.h" />
<ClInclude Include="libdrizzle-2.0\visibility.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

171
utils/mysqlcl_idb/libmysqlcl_idb.vcxproj.filters
View File

@ -1,171 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="column.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="command.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="conn.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="conn_uds.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="drizzle.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="field.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="handshake.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="pack.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="query.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="result.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="row.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="sha1.cc">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="state.cc">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="libdrizzle-2.0\column.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\column_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\column_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\command.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\command_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\command_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\conn.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\conn_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\conn_local.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\conn_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\constants.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\deprecated_enum.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\drizzle.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\drizzle_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\drizzle_local.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\drizzle_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\field_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\field_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\handshake_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\handshake_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\libdrizzle.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\libdrizzle.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\limits.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\pack.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\query.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\result.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\result_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\result_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\return.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\row_client.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\row_server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\sha1.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\state.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\structs.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\verbose.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="libdrizzle-2.0\visibility.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>

153
utils/mysqlcl_idb/mysqlcl_idb.vpj
View File

@ -1,153 +0,0 @@
<!DOCTYPE Project SYSTEM "http://www.slickedit.com/dtd/vse/10.0/vpj.dtd">
<Project
Version="10.0"
VendorName="SlickEdit"
TemplateName="Makefile"
WorkingDir="."
BuildSystem=""
BuildMakeFile="Makefile">
<Config
Name="Release"
Type="Makefile"
OutputFile="mysqlcl_idb"
CompilerConfigName="">
<Menu>
<Target
Name="Compile"
MenuCaption="&amp;Compile"
CaptureOutputWith="ProcessBuffer"
SaveOption="SaveCurrent"
RunFromDir="%rw">
<Exec/>
</Target>
<Target
Name="Build"
MenuCaption="&amp;Build"
CaptureOutputWith="ProcessBuffer"
SaveOption="SaveWorkspaceFiles"
RunFromDir="%rw">
<Exec CmdLine="make -f Makefile all"/>
</Target>
<Target
Name="Rebuild"
MenuCaption="&amp;Rebuild"
CaptureOutputWith="ProcessBuffer"
SaveOption="SaveWorkspaceFiles"
RunFromDir="%rw">
<Exec CmdLine="make -f Makefile clean all"/>
</Target>
<Target
Name="Debug"
MenuCaption="&amp;Debug"
SaveOption="SaveNone"
RunFromDir="%rw">
<Exec/>
</Target>
<Target
Name="Execute"
MenuCaption="E&amp;xecute"
SaveOption="SaveNone"
RunFromDir="%rw">
<Exec CmdLine='"mysqlcl_idb.exe"'/>
</Target>
</Menu>
</Config>
<Files>
<Folder
Name="Source Files"
Filters="*.c;*.C;*.cc;*.cpp;*.cp;*.cxx;*.c++;*.prg;*.pas;*.dpr;*.asm;*.s;*.bas;*.java;*.cs;*.sc;*.e;*.cob;*.html;*.rc;*.tcl;*.py;*.pl;*.d">
<F N="array.c"/>
<F N="bchange.c"/>
<F N="bmove_upp.c"/>
<F N="charset-def.c"/>
<F N="charset.c"/>
<F N="client.c"/>
<F N="ctype-bin.c"/>
<F N="ctype-extra.c"/>
<F N="ctype-latin1.c"/>
<F N="ctype-mb.c"/>
<F N="ctype-simple.c"/>
<F N="ctype-uca.c"/>
<F N="ctype-utf8.c"/>
<F N="ctype.c"/>
<F N="dbug.c"/>
<F N="default.c"/>
<F N="errmsg.c"/>
<F N="errors.c"/>
<F N="int2str.c"/>
<F N="is_prefix.c"/>
<F N="libmysql.c"/>
<F N="list.c"/>
<F N="mf_arr_appstr.c"/>
<F N="mf_dirname.c"/>
<F N="mf_fn_ext.c"/>
<F N="mf_format.c"/>
<F N="mf_loadpath.c"/>
<F N="mf_pack.c"/>
<F N="mf_qsort.c"/>
<F N="mulalloc.c"/>
<F N="my_alloc.c"/>
<F N="my_compress.c"/>
<F N="my_div.c"/>
<F N="my_error.c"/>
<F N="my_fopen.c"/>
<F N="my_gethostbyname.c"/>
<F N="my_getwd.c"/>
<F N="my_init.c"/>
<F N="my_lib.c"/>
<F N="my_malloc.c"/>
<F N="my_messnc.c"/>
<F N="my_net.c"/>
<F N="my_once.c"/>
<F N="my_open.c"/>
<F N="my_pthread.c"/>
<F N="my_read.c"/>
<F N="my_realloc.c"/>
<F N="my_static.c"/>
<F N="my_strtoll10.c"/>
<F N="my_symlink.c"/>
<F N="my_sync.c"/>
<F N="my_thr_init.c"/>
<F N="my_time.c"/>
<F N="my_vsnprintf.c"/>
<F N="net.c"/>
<F N="pack.c"/>
<F N="password.c"/>
<F N="sha1.c"/>
<F N="str2int.c"/>
<F N="strcend.c"/>
<F N="strend.c"/>
<F N="strmake.c"/>
<F N="strnmov.c"/>
<F N="strtod.c"/>
<F N="strxmov.c"/>
<F N="thr_mutex.c"/>
<F N="typelib.c"/>
<F N="vio.c"/>
<F N="viosocket.c"/>
<F N="xml.c"/>
</Folder>
<Folder
Name="Header Files"
Filters="*.h;*.H;*.hh;*.hpp;*.hxx;*.inc;*.sh;*.cpy;*.if">
<F N="client_settings.h"/>
<F N="my_static.h"/>
<F N="mysql.h"/>
<F N="mysys_priv.h"/>
<F N="vio_priv.h"/>
</Folder>
<Folder
Name="Resource Files"
Filters="*.ico;*.cur;*.dlg"/>
<Folder
Name="Bitmaps"
Filters="*.bmp"/>
<Folder
Name="Other Files"
Filters="">
<F
N="Makefile"
Type="Makefile"/>
</Folder>
</Files>
</Project>

336
utils/mysqlcl_idb/pack.cc
View File

@ -1,336 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Packing definitions
*/
#include <libdrizzle-2.0/common.h>
/*
* Private declarations
*/
/**
* @addtogroup drizzle_pack_private Private Packing Functions
* @ingroup drizzle_pack
* @{
*/
/**
* Compute hash from password and scramble.
*/
static drizzle_return_t _pack_scramble_hash(drizzle_con_st *con,
uint8_t *buffer);
/** @} */
/*
* Public definitions
*/
uint8_t *drizzle_pack_length(uint64_t number, uint8_t *ptr)
{
if (number < 251)
{
ptr[0]= (uint8_t)number;
ptr++;
}
else if (number < 65536)
{
ptr[0]= 252;
ptr++;
drizzle_set_byte2(ptr, number);
ptr+= 2;
}
else if (number < 16777216)
{
ptr[0]= 253;
ptr++;
drizzle_set_byte3(ptr, number);
ptr+= 3;
}
else
{
ptr[0]= 254;
ptr++;
drizzle_set_byte8(ptr, number);
ptr+= 8;
}
return ptr;
}
uint64_t drizzle_unpack_length(drizzle_con_st *con, drizzle_return_t *ret_ptr)
{
uint64_t length;
uint8_t bytes;
if (con->buffer_ptr[0] < 251)
{
length= (uint64_t)(con->buffer_ptr[0]);
bytes= 1;
}
else if (con->buffer_ptr[0] == 251)
{
con->buffer_ptr++;
con->buffer_size--;
con->packet_size--;
*ret_ptr= DRIZZLE_RETURN_NULL_SIZE;
return 0;
}
else if (con->buffer_ptr[0] == 252 && con->buffer_size > 2)
{
length= drizzle_get_byte2(con->buffer_ptr + 1);
bytes= 3;
}
else if (con->buffer_ptr[0] == 253 && con->buffer_size > 3)
{
length= drizzle_get_byte3(con->buffer_ptr + 1);
bytes= 4;
}
else if (con->buffer_size > 8)
{
length= drizzle_get_byte8(con->buffer_ptr + 1);
bytes= 9;
}
else
{
*ret_ptr= DRIZZLE_RETURN_IO_WAIT;
return 0;
}
con->buffer_ptr+= bytes;
con->buffer_size-= bytes;
con->packet_size-= bytes;
*ret_ptr= DRIZZLE_RETURN_OK;
return length;
}
uint8_t *drizzle_pack_string(char *string, uint8_t *ptr)
{
if (string == NULL)
{
return NULL;
}
uint64_t size= strlen(string);
ptr= drizzle_pack_length(size, ptr);
if (size > 0)
{
memcpy(ptr, string, (size_t)size);
ptr+= size;
}
return ptr;
}
drizzle_return_t drizzle_unpack_string(drizzle_con_st *con, char *buffer,
uint64_t max_length)
{
drizzle_return_t ret= DRIZZLE_RETURN_OK;
uint64_t length;
if (con == NULL)
{
return DRIZZLE_RETURN_INVALID_ARGUMENT;
}
length= drizzle_unpack_length(con, &ret);
if (ret != DRIZZLE_RETURN_OK)
{
if (ret == DRIZZLE_RETURN_NULL_SIZE)
{
drizzle_set_error(con->drizzle, "drizzle_unpack_string",
"unexpected NULL length");
}
return ret;
}
if (length < max_length)
{
if (length > 0)
{
memcpy(buffer, con->buffer_ptr, (size_t)length);
}
buffer[length]= 0;
}
else
{
memcpy(buffer, con->buffer_ptr, (size_t)(max_length - 1));
buffer[max_length - 1]= 0;
}
con->buffer_ptr+= length;
con->buffer_size-= (size_t)length;
con->packet_size-= (size_t)length;
return DRIZZLE_RETURN_OK;
}
uint8_t *drizzle_pack_auth(drizzle_con_st *con, uint8_t *ptr, drizzle_return_t *ret_ptr)
{
if (con == NULL)
{
return NULL;
}
drizzle_return_t unused;
if (ret_ptr == NULL)
{
ret_ptr= &unused;
}
if (con->user[0] != 0)
{
memcpy(ptr, con->user, strlen(con->user));
ptr+= strlen(con->user);
}
ptr[0]= 0;
ptr++;
if (con->options & DRIZZLE_CON_RAW_SCRAMBLE && con->scramble != NULL)
{
ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
ptr++;
memcpy(ptr, con->scramble, DRIZZLE_MAX_SCRAMBLE_SIZE);
ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
}
else if (con->password[0] == 0)
{
ptr[0]= 0;
ptr++;
con->packet_size-= DRIZZLE_MAX_SCRAMBLE_SIZE;
}
else
{
ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
ptr++;
if (con->options & DRIZZLE_CON_MYSQL && con->options & DRIZZLE_CON_AUTH_PLUGIN)
{
snprintf((char *)ptr, DRIZZLE_MAX_SCRAMBLE_SIZE, "%s", con->password);
ptr[DRIZZLE_MAX_SCRAMBLE_SIZE-1]= 0;
}
else if (con->options & DRIZZLE_CON_MYSQL)
{
*ret_ptr= _pack_scramble_hash(con, ptr);
if (*ret_ptr != DRIZZLE_RETURN_OK)
{
return ptr;
}
}
else // We assume Drizzle
{
snprintf((char *)ptr, DRIZZLE_MAX_SCRAMBLE_SIZE, "%s", con->password);
ptr[DRIZZLE_MAX_SCRAMBLE_SIZE-1]= 0;
}
ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
}
if (con->schema[0] != 0)
{
memcpy(ptr, con->schema, strlen(con->schema));
ptr+= strlen(con->schema);
}
ptr[0]= 0;
ptr++;
*ret_ptr= DRIZZLE_RETURN_OK;
return ptr;
}
/*
* Private definitions
*/
static drizzle_return_t _pack_scramble_hash(drizzle_con_st *con,
uint8_t *buffer)
{
SHA1_CTX ctx;
uint8_t hash_tmp1[SHA1_DIGEST_LENGTH];
uint8_t hash_tmp2[SHA1_DIGEST_LENGTH];
if (SHA1_DIGEST_LENGTH != DRIZZLE_MAX_SCRAMBLE_SIZE)
{
drizzle_set_error(con->drizzle, "_pack_scramble_hash",
"SHA1 hash size mismatch:%u:%u", SHA1_DIGEST_LENGTH,
DRIZZLE_MAX_SCRAMBLE_SIZE);
return DRIZZLE_RETURN_INTERNAL_ERROR;
}
if (con->scramble == NULL)
{
drizzle_set_error(con->drizzle, "_pack_scramble_hash",
"no scramble buffer");
return DRIZZLE_RETURN_NO_SCRAMBLE;
}
/* First hash the password. */
SHA1Init(&ctx);
SHA1Update(&ctx, (uint8_t *)(con->password), strlen(con->password));
SHA1Final(hash_tmp1, &ctx);
/* Second, hash the password hash. */
SHA1Init(&ctx);
SHA1Update(&ctx, hash_tmp1, SHA1_DIGEST_LENGTH);
SHA1Final(hash_tmp2, &ctx);
/* Third, hash the scramble and the double password hash. */
SHA1Init(&ctx);
SHA1Update(&ctx, con->scramble, SHA1_DIGEST_LENGTH);
SHA1Update(&ctx, hash_tmp2, SHA1_DIGEST_LENGTH);
SHA1Final(buffer, &ctx);
/* Fourth, xor the last hash against the first password hash. */
for (uint32_t x= 0; x < SHA1_DIGEST_LENGTH; x++)
{
buffer[x]= buffer[x] ^ hash_tmp1[x];
}
return DRIZZLE_RETURN_OK;
}

545
utils/mysqlcl_idb/query.cc
View File

@ -1,545 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Query definitions
*/
#include <libdrizzle-2.0/common.h>
drizzle_result_st *drizzle_query(drizzle_con_st *con, drizzle_result_st *result,
const char *query, size_t size,
drizzle_return_t *ret_ptr)
{
return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY,
(uint8_t *)query, size, size, ret_ptr);
}
drizzle_result_st *drizzle_query_str(drizzle_con_st *con,
drizzle_result_st *result,
const char *query,
drizzle_return_t *ret_ptr)
{
size_t size= strlen(query);
return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY, (uint8_t *)query, size, size, ret_ptr);
}
drizzle_result_st *drizzle_query_inc(drizzle_con_st *con,
drizzle_result_st *result,
const char *query, size_t size,
size_t total, drizzle_return_t *ret_ptr)
{
return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY, (uint8_t *)query, size, total, ret_ptr);
}
drizzle_query_st *drizzle_query_add(drizzle_st *drizzle,
drizzle_query_st *query,
drizzle_con_st *con,
drizzle_result_st *result,
const char *query_string, size_t size,
drizzle_query_options_t,
void *context)
{
// @note drizzle_query_st handle the null drizzle case
query= drizzle_query_create(drizzle, query);
if (query == NULL)
{
return NULL;
}
drizzle_query_set_con(query, con);
drizzle_query_set_result(query, result);
drizzle_query_set_string(query, query_string, size);
drizzle_query_set_context(query, context);
return query;
}
drizzle_query_st *drizzle_query_create(drizzle_st *drizzle, drizzle_query_st *query)
{
if (drizzle == NULL)
{
return NULL;
}
if (query == NULL)
{
query= new (std::nothrow) drizzle_query_st;
if (query == NULL)
{
return NULL;
}
query->options.is_allocated= true;
}
else
{
query->prev= NULL;
query->state= DRIZZLE_QUERY_STATE_INIT;
query->con= NULL;
query->result= NULL;
query->string= NULL;
query->size= 0;
query->context= NULL;
query->context_free_fn= NULL;
query->options.is_allocated= false;
}
query->drizzle= drizzle;
if (drizzle->query_list)
{
drizzle->query_list->prev= query;
}
query->next= drizzle->query_list;
drizzle->query_list= query;
drizzle->query_count++;
drizzle->query_new++;
return query;
}
void drizzle_query_free(drizzle_query_st *query)
{
if (query == NULL)
{
return;
}
if (query->context != NULL && query->context_free_fn != NULL)
{
query->context_free_fn(query, query->context);
}
if (query->drizzle->query_list == query)
{
query->drizzle->query_list= query->next;
}
if (query->prev)
{
query->prev->next= query->next;
}
if (query->next)
{
query->next->prev= query->prev;
}
query->drizzle->query_count--;
if (query->options.is_allocated)
{
delete query;
}
}
void drizzle_query_free_all(drizzle_st *drizzle)
{
while (drizzle->query_list != NULL)
{
drizzle_query_free(drizzle->query_list);
}
}
drizzle_con_st *drizzle_query_con(drizzle_query_st *query)
{
if (query == NULL)
{
return NULL;
}
return query->con;
}
void drizzle_query_set_con(drizzle_query_st *query, drizzle_con_st *con)
{
if (query == NULL)
{
return;
}
query->con= con;
}
drizzle_result_st *drizzle_query_result(drizzle_query_st *query)
{
if (query == NULL)
{
return NULL;
}
return query->result;
}
void drizzle_query_set_result(drizzle_query_st *query,
drizzle_result_st *result)
{
if (query == NULL)
{
return;
}
query->result= result;
}
char *drizzle_query_string(drizzle_query_st *query, size_t *size)
{
if (query == NULL)
{
return NULL;
}
*size= query->size;
return (char *)(query->string);
}
void drizzle_query_set_string(drizzle_query_st *query, const char *string,
size_t size)
{
if (query == NULL)
{
return;
}
query->string= string;
query->size= size;
}
int drizzle_query_options(drizzle_query_st *)
{
return 0;
}
void drizzle_query_set_options(drizzle_query_st *, int)
{
}
void drizzle_query_add_options(drizzle_query_st *, int)
{
}
void drizzle_query_remove_options(drizzle_query_st *, int)
{
}
void *drizzle_query_context(drizzle_query_st *query)
{
if (query == NULL)
{
return NULL;
}
return query->context;
}
void drizzle_query_set_context(drizzle_query_st *query, void *context)
{
if (query == NULL)
{
return;
}
query->context= context;
}
void drizzle_query_set_context_free_fn(drizzle_query_st *query,
drizzle_query_context_free_fn *function)
{
if (query == NULL)
{
return;
}
query->context_free_fn= function;
}
static void drizzle_query_run_state(drizzle_query_st* query,
drizzle_return_t* ret_ptr)
{
if (query == NULL)
{
return;
}
switch (query->state)
{
case DRIZZLE_QUERY_STATE_INIT:
query->state= DRIZZLE_QUERY_STATE_QUERY;
case DRIZZLE_QUERY_STATE_QUERY:
query->result= drizzle_query(query->con, query->result, query->string,
query->size, ret_ptr);
if (*ret_ptr == DRIZZLE_RETURN_IO_WAIT)
{
return;
}
else if (*ret_ptr != DRIZZLE_RETURN_OK)
{
query->state= DRIZZLE_QUERY_STATE_DONE;
return;
}
query->state= DRIZZLE_QUERY_STATE_RESULT;
case DRIZZLE_QUERY_STATE_RESULT:
*ret_ptr= drizzle_result_buffer(query->result);
if (*ret_ptr == DRIZZLE_RETURN_IO_WAIT)
{
return;
}
query->state= DRIZZLE_QUERY_STATE_DONE;
return;
default:
case DRIZZLE_QUERY_STATE_DONE:
return;
}
}
drizzle_query_st *drizzle_query_run(drizzle_st *drizzle,
drizzle_return_t *ret_ptr)
{
drizzle_return_t unused;
if (ret_ptr == NULL)
{
ret_ptr= &unused;
}
if (drizzle == NULL)
{
*ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
return NULL;
}
if (drizzle->query_new == 0 && drizzle->query_running == 0)
{
*ret_ptr= DRIZZLE_RETURN_OK;
return NULL;
}
drizzle_st::options_t options= drizzle->options;
drizzle->options.is_non_blocking= false;
/* Check to see if any queries need to be started. */
if (drizzle->query_new > 0)
{
for (drizzle_query_st *query= drizzle->query_list; query != NULL; query= query->next)
{
if (query->state != DRIZZLE_QUERY_STATE_INIT)
{
continue;
}
drizzle->query_new--;
drizzle->query_running++;
assert(query->con->query == NULL);
query->con->query= query;
drizzle_query_run_state(query, ret_ptr);
if (*ret_ptr != DRIZZLE_RETURN_IO_WAIT)
{
assert(query->state == DRIZZLE_QUERY_STATE_DONE);
drizzle->query_running--;
drizzle->options= options;
query->con->query= NULL;
if (*ret_ptr == DRIZZLE_RETURN_ERROR_CODE || *ret_ptr == DRIZZLE_RETURN_OK)
{
return query;
}
return NULL;
}
}
assert(drizzle->query_new == 0);
}
while (1)
{
drizzle_con_st *con;
/* Loop through each active connection. */
while ((con= drizzle_con_ready(drizzle)) != NULL)
{
drizzle_query_st *query= con->query;
drizzle_query_run_state(query, ret_ptr);
if (query->state == DRIZZLE_QUERY_STATE_DONE)
{
drizzle->query_running--;
drizzle->options= options;
con->query= NULL;
return query;
}
assert(*ret_ptr == DRIZZLE_RETURN_IO_WAIT);
}
if (options.is_non_blocking)
{
*ret_ptr= DRIZZLE_RETURN_IO_WAIT;
return NULL;
}
*ret_ptr= drizzle_con_wait(drizzle);
if (*ret_ptr != DRIZZLE_RETURN_OK)
{
drizzle->options= options;
return NULL;
}
}
}
drizzle_return_t drizzle_query_run_all(drizzle_st *drizzle)
{
if (drizzle == NULL)
{
return DRIZZLE_RETURN_INVALID_ARGUMENT;
}
while (drizzle->query_new > 0 || drizzle->query_running > 0)
{
drizzle_return_t ret;
(void)drizzle_query_run(drizzle, &ret);
if (ret != DRIZZLE_RETURN_OK && ret != DRIZZLE_RETURN_ERROR_CODE)
{
return ret;
}
}
return DRIZZLE_RETURN_OK;
}
ssize_t drizzle_escape_string(char *to, size_t max_to_size, const char *from, size_t from_size)
{
ssize_t to_size= 0;
char newchar;
const char *end;
for (end= from + from_size; from < end; from++)
{
newchar= 0;
/* All multi-byte UTF8 characters have the high bit set for all bytes. */
if (!(*from & 0x80))
{
switch (*from)
{
case 0:
newchar= '0';
break;
case '\n':
newchar= 'n';
break;
case '\r':
newchar= 'r';
break;
case '\032':
newchar= 'Z';
break;
case '\\':
newchar= '\\';
break;
case '\'':
newchar= '\'';
break;
case '"':
newchar= '"';
break;
default:
break;
}
}
if (newchar != '\0')
{
if ((size_t)to_size + 2 > max_to_size)
{
return -1;
}
*to++= '\\';
*to++= newchar;
to_size++;
}
else
{
if ((size_t)to_size + 1 > max_to_size)
{
return -1;
}
*to++= *from;
}
to_size++;
}
*to= 0;
return to_size;
}
size_t drizzle_hex_string(char *to, const char *from, size_t from_size)
{
static const char hex_map[]= "0123456789ABCDEF";
const char *from_end;
for (from_end= from + from_size; from != from_end; from++)
{
*to++= hex_map[((unsigned char) *from) >> 4];
*to++= hex_map[((unsigned char) *from) & 0xF];
}
*to= 0;
return from_size * 2;
}
void drizzle_mysql_password_hash(char *to, const char *from, size_t from_size)
{
SHA1_CTX ctx;
uint8_t hash_tmp1[SHA1_DIGEST_LENGTH];
uint8_t hash_tmp2[SHA1_DIGEST_LENGTH];
SHA1Init(&ctx);
SHA1Update(&ctx, (const uint8_t*)from, from_size);
SHA1Final(hash_tmp1, &ctx);
SHA1Init(&ctx);
SHA1Update(&ctx, hash_tmp1, SHA1_DIGEST_LENGTH);
SHA1Final(hash_tmp2, &ctx);
(void)drizzle_hex_string(to, (char*)hash_tmp2, SHA1_DIGEST_LENGTH);
}

803
utils/mysqlcl_idb/result.cc
View File

@ -1,803 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief Result definitions
*/
#include <libdrizzle-2.0/common.h>
#include <memory>
/*
* Common definitions
*/
drizzle_result_st *drizzle_result_create(drizzle_con_st *con)
{
return drizzle_result_create_with(con, NULL);
}
drizzle_result_st *drizzle_result_create_with(drizzle_con_st *con,
drizzle_result_st *result)
{
if (result == NULL)
{
result= new (std::nothrow) drizzle_result_st;
if (result == NULL)
{
return NULL;
}
result->row= NULL;
result->field_buffer= NULL;
result->_options.is_allocated= true;
}
else
{
result->prev= NULL;
result->options= 0;
result->info[0]= '\0';
result->error_code= 0;
result->sqlstate[0]= '\0';
result->insert_id= 0;
result->warning_count= 0;
result->affected_rows= 0;
result->column_count= 0;
result->column_current= 0;
result->column_list= NULL;
result->column= NULL;
result->column_buffer= NULL;
result->row_count= 0;
result->row_current= 0;
result->field_current= 0;
result->field_total= 0;
result->field_offset= 0;
result->field_size= 0;
result->field= NULL;
result->field_buffer= NULL;
result->row_list_size= 0;
result->row= NULL;
result->row_list= NULL;
result->field_sizes= NULL;
result->field_sizes_list= NULL;
result->_options.is_allocated= false;
}
result->con= con;
con->result= result;
if (con->result_list)
con->result_list->prev= result;
result->next= con->result_list;
con->result_list= result;
con->result_count++;
return result;
}
drizzle_result_st *drizzle_result_clone(drizzle_con_st *con,
drizzle_result_st *source)
{
drizzle_result_st *result= drizzle_result_create(con);
if (result == NULL)
{
return NULL;
}
result->options= source->options;
drizzle_result_set_info(result, source->info);
result->error_code= source->error_code;
drizzle_result_set_sqlstate(result, source->sqlstate);
result->warning_count= source->warning_count;
result->insert_id= source->insert_id;
result->affected_rows= source->affected_rows;
result->column_count= source->column_count;
result->row_count= source->row_count;
return result;
}
void drizzle_result_free(drizzle_result_st *result)
{
drizzle_column_st *column;
if (result == NULL)
{
return;
}
for (column= result->column_list; column != NULL; column= result->column_list)
{
drizzle_column_free(column);
}
delete[] result->column_buffer;
if (result->options & DRIZZLE_RESULT_BUFFER_ROW)
{
for (size_t x= 0; x < result->row_count; x++)
{
drizzle_row_free(result, result->row_list->at(x));
}
delete result->row_list;
delete result->field_sizes_list;
}
if (result->con)
{
result->con->result_count--;
if (result->con->result_list == result)
result->con->result_list= result->next;
}
if (result->prev)
result->prev->next= result->next;
if (result->next)
result->next->prev= result->prev;
if (result->_options.is_allocated)
{
delete result;
}
}
void drizzle_result_free_all(drizzle_con_st *con)
{
while (con->result_list != NULL)
{
drizzle_result_free(con->result_list);
}
}
drizzle_con_st *drizzle_result_drizzle_con(drizzle_result_st *result)
{
if (result == NULL)
{
return NULL;
}
return result->con;
}
bool drizzle_result_eof(drizzle_result_st *result)
{
if (result == NULL)
{
return false;
}
return (result->options & DRIZZLE_RESULT_EOF_PACKET) ? true : false;
}
const char *drizzle_result_info(drizzle_result_st *result)
{
if (result == NULL)
{
return NULL;
}
return result->info;
}
const char *drizzle_result_error(drizzle_result_st *result)
{
if (result == NULL)
{
return NULL;
}
return result->info;
}
uint16_t drizzle_result_error_code(drizzle_result_st *result)
{
if (result == NULL)
{
return 0;
}
return result->error_code;
}
const char *drizzle_result_sqlstate(drizzle_result_st *result)
{
if (result == NULL)
{
return NULL;
}
return result->sqlstate;
}
uint16_t drizzle_result_warning_count(drizzle_result_st *result)
{
if (result == NULL)
{
return 0;
}
return result->warning_count;
}
uint64_t drizzle_result_insert_id(drizzle_result_st *result)
{
if (result == NULL)
{
return 0;
}
return result->insert_id;
}
uint64_t drizzle_result_affected_rows(drizzle_result_st *result)
{
if (result == NULL)
{
return 0;
}
return result->affected_rows;
}
uint16_t drizzle_result_column_count(drizzle_result_st *result)
{
if (result == NULL)
{
return 0;
}
return result->column_count;
}
uint64_t drizzle_result_row_count(drizzle_result_st *result)
{
if (result == NULL)
{
return 0;
}
return result->row_count;
}
/*
* Client definitions
*/
drizzle_result_st *drizzle_result_read(drizzle_con_st *con,
drizzle_result_st *result,
drizzle_return_t *ret_ptr)
{
drizzle_return_t unused;
if (ret_ptr == NULL)
{
ret_ptr= &unused;
}
if (con == NULL)
{
*ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
return NULL;
}
if (drizzle_state_none(con))
{
con->result= drizzle_result_create_with(con, result);
if (con->result == NULL)
{
*ret_ptr= DRIZZLE_RETURN_MEMORY;
return NULL;
}
drizzle_state_push(con, drizzle_state_result_read);
drizzle_state_push(con, drizzle_state_packet_read);
}
*ret_ptr= drizzle_state_loop(con);
return con->result;
}
drizzle_return_t drizzle_result_buffer(drizzle_result_st *result)
{
if (result == NULL)
{
return DRIZZLE_RETURN_INVALID_ARGUMENT;
}
if (!(result->options & DRIZZLE_RESULT_BUFFER_COLUMN))
{
drizzle_return_t ret= drizzle_column_buffer(result);
if (ret != DRIZZLE_RETURN_OK)
{
return ret;
}
}
if (result->column_count == 0)
{
result->options|= DRIZZLE_RESULT_BUFFER_ROW;
return DRIZZLE_RETURN_OK;
}
while (1)
{
drizzle_return_t ret;
drizzle_row_t row= drizzle_row_buffer(result, &ret);
if (ret != DRIZZLE_RETURN_OK)
{
return ret;
}
if (row == NULL)
{
break;
}
if (result->row_list == NULL)
{
result->row_list= new (std::nothrow) drizzle_row_list_t;
if (result->row_list == NULL)
{
return DRIZZLE_RETURN_MEMORY;
}
}
if (result->field_sizes_list == NULL)
{
result->field_sizes_list= new (std::nothrow) drizzle_field_sizes_list_t;
if (result->field_sizes_list == NULL)
{
}
}
result->row_list->push_back(row);
result->field_sizes_list->push_back(result->field_sizes);
}
result->options|= DRIZZLE_RESULT_BUFFER_ROW;
return DRIZZLE_RETURN_OK;
}
size_t drizzle_result_row_size(drizzle_result_st *result)
{
if (result == NULL)
{
return 0;
}
return result->con->packet_size;
}
/*
* Server definitions
*/
drizzle_return_t drizzle_result_write(drizzle_con_st *con,
drizzle_result_st *result, bool flush)
{
if (con == NULL)
{
return DRIZZLE_RETURN_INVALID_ARGUMENT;
}
if (drizzle_state_none(con))
{
con->result= result;
if (flush)
drizzle_state_push(con, drizzle_state_write);
drizzle_state_push(con, drizzle_state_result_write);
}
return drizzle_state_loop(con);
}
void drizzle_result_set_row_size(drizzle_result_st *result, size_t size)
{
if (result == NULL)
{
return;
}
result->con->packet_size= size;
}
void drizzle_result_calc_row_size(drizzle_result_st *result,
const drizzle_field_t *field,
const size_t *size)
{
if (result == NULL)
{
return;
}
result->con->packet_size= 0;
for (uint16_t x= 0; x < result->column_count; x++)
{
if (field[x] == NULL)
{
result->con->packet_size++;
}
else if (size[x] < 251)
{
result->con->packet_size+= (1 + size[x]);
}
else if (size[x] < 65536)
{
result->con->packet_size+= (3 + size[x]);
}
else if (size[x] < 16777216)
{
result->con->packet_size+= (4 + size[x]);
}
else
{
result->con->packet_size+= (9 + size[x]);
}
}
}
void drizzle_result_set_eof(drizzle_result_st *result, bool is_eof)
{
if (result == NULL)
{
return;
}
if (is_eof)
{
result->options|= DRIZZLE_RESULT_EOF_PACKET;
}
else
{
result->options&= ~DRIZZLE_RESULT_EOF_PACKET;
}
}
void drizzle_result_set_info(drizzle_result_st *result, const char *info)
{
if (result == NULL)
{
return;
}
if (info == NULL)
{
result->info[0]= 0;
}
else
{
strncpy(result->info, info, DRIZZLE_MAX_INFO_SIZE);
result->info[DRIZZLE_MAX_INFO_SIZE - 1]= 0;
}
}
void drizzle_result_set_error(drizzle_result_st *result, const char *error)
{
if (result == NULL)
{
return;
}
drizzle_result_set_info(result, error);
}
void drizzle_result_set_error_code(drizzle_result_st *result,
uint16_t error_code)
{
if (result == NULL)
{
return;
}
result->error_code= error_code;
}
void drizzle_result_set_sqlstate(drizzle_result_st *result,
const char *sqlstate)
{
if (result == NULL)
{
return;
}
if (sqlstate == NULL)
{
result->sqlstate[0]= 0;
}
else
{
strncpy(result->sqlstate, sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE + 1);
result->sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE]= 0;
}
}
void drizzle_result_set_warning_count(drizzle_result_st *result,
uint16_t warning_count)
{
if (result == NULL)
{
return;
}
result->warning_count= warning_count;
}
void drizzle_result_set_insert_id(drizzle_result_st *result,
uint64_t insert_id)
{
if (result == NULL)
{
return;
}
result->insert_id= insert_id;
}
void drizzle_result_set_affected_rows(drizzle_result_st *result,
uint64_t affected_rows)
{
if (result == NULL)
{
return;
}
result->affected_rows= affected_rows;
}
void drizzle_result_set_column_count(drizzle_result_st *result,
uint16_t column_count)
{
if (result == NULL)
{
return;
}
result->column_count= column_count;
}
/*
* Internal state functions.
*/
drizzle_return_t drizzle_state_result_read(drizzle_con_st *con)
{
drizzle_return_t ret;
if (con == NULL)
{
return DRIZZLE_RETURN_INVALID_ARGUMENT;
}
drizzle_log_debug(con->drizzle, "drizzle_state_result_read");
/* Assume the entire result packet will fit in the buffer. */
if (con->buffer_size < con->packet_size)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
if (con->buffer_ptr[0] == 0)
{
con->buffer_ptr++;
/* We can ignore the returns since we've buffered the entire packet. */
con->result->affected_rows= drizzle_unpack_length(con, &ret);
con->result->insert_id= drizzle_unpack_length(con, &ret);
con->status= (drizzle_con_status_t)drizzle_get_byte2(con->buffer_ptr);
con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 2);
con->buffer_ptr+= 4;
con->buffer_size-= 5;
con->packet_size-= 5;
if (con->packet_size > 0)
{
/* Skip one byte for message size. */
con->buffer_ptr+= 1;
con->buffer_size-= 1;
con->packet_size-= 1;
}
ret= DRIZZLE_RETURN_OK;
}
else if (con->buffer_ptr[0] == 254)
{
con->result->options= DRIZZLE_RESULT_EOF_PACKET;
con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 1);
con->status= (drizzle_con_status_t)drizzle_get_byte2(con->buffer_ptr + 3);
con->buffer_ptr+= 5;
con->buffer_size-= 5;
con->packet_size-= 5;
ret= DRIZZLE_RETURN_OK;
}
else if (con->buffer_ptr[0] == 255)
{
con->result->error_code= drizzle_get_byte2(con->buffer_ptr + 1);
con->drizzle->error_code= con->result->error_code;
/* Byte 3 is always a '#' character, skip it. */
memcpy(con->result->sqlstate, con->buffer_ptr + 4,
DRIZZLE_MAX_SQLSTATE_SIZE);
con->result->sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE]= 0;
memcpy(con->drizzle->sqlstate, con->result->sqlstate,
DRIZZLE_MAX_SQLSTATE_SIZE + 1);
con->buffer_ptr+= 9;
con->buffer_size-= 9;
con->packet_size-= 9;
ret= DRIZZLE_RETURN_ERROR_CODE;
}
else
{
/* We can ignore the return since we've buffered the entire packet. */
con->result->column_count= (uint16_t)drizzle_unpack_length(con, &ret);
ret= DRIZZLE_RETURN_OK;
}
if (con->packet_size > 0)
{
snprintf(con->drizzle->last_error, DRIZZLE_MAX_ERROR_SIZE, "%.*s",
(int32_t)con->packet_size, con->buffer_ptr);
con->drizzle->last_error[DRIZZLE_MAX_ERROR_SIZE-1]= 0;
snprintf(con->result->info, DRIZZLE_MAX_INFO_SIZE, "%.*s",
(int32_t)con->packet_size, con->buffer_ptr);
con->result->info[DRIZZLE_MAX_INFO_SIZE-1]= 0;
con->buffer_ptr+= con->packet_size;
con->buffer_size-= con->packet_size;
con->packet_size= 0;
}
drizzle_state_pop(con);
return ret;
}
drizzle_return_t drizzle_state_result_write(drizzle_con_st *con)
{
if (con == NULL)
{
return DRIZZLE_RETURN_INVALID_ARGUMENT;
}
uint8_t *start= con->buffer_ptr + con->buffer_size;
uint8_t *ptr;
drizzle_result_st *result= con->result;
drizzle_log_debug(con->drizzle, "drizzle_state_result_write");
/* Calculate max packet size. */
con->packet_size= 1 /* OK/Field Count/EOF/Error */
+ 9 /* Affected rows */
+ 9 /* Insert ID */
+ 2 /* Status */
+ 2 /* Warning count */
+ strlen(result->info); /* Info/error message */
/* Assume the entire result packet will fit in the buffer. */
if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
{
drizzle_set_error(con->drizzle, "drizzle_state_result_write", "buffer too small:%zu", con->packet_size + 4);
return DRIZZLE_RETURN_INTERNAL_ERROR;
}
/* Flush buffer if there is not enough room. */
if (((size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer)) <
con->packet_size)
{
drizzle_state_push(con, drizzle_state_write);
return DRIZZLE_RETURN_OK;
}
/* Store packet size at the end since it may change. */
ptr= start;
ptr[3]= con->packet_number;
con->packet_number++;
ptr+= 4;
if (result->options & DRIZZLE_RESULT_EOF_PACKET)
{
ptr[0]= 254;
ptr++;
drizzle_set_byte2(ptr, result->warning_count);
ptr+= 2;
drizzle_set_byte2(ptr, con->status);
ptr+= 2;
}
else if (result->error_code != 0)
{
ptr[0]= 255;
ptr++;
drizzle_set_byte2(ptr, result->error_code);
ptr+= 2;
ptr[0]= '#';
ptr++;
memcpy(ptr, result->sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE);
ptr+= DRIZZLE_MAX_SQLSTATE_SIZE;
memcpy(ptr, result->info, strlen(result->info));
ptr+= strlen(result->info);
}
else if (result->column_count == 0)
{
ptr[0]= 0;
ptr++;
ptr= drizzle_pack_length(result->affected_rows, ptr);
ptr= drizzle_pack_length(result->insert_id, ptr);
drizzle_set_byte2(ptr, con->status);
ptr+= 2;
drizzle_set_byte2(ptr, result->warning_count);
ptr+= 2;
memcpy(ptr, result->info, strlen(result->info));
ptr+= strlen(result->info);
}
else
ptr= drizzle_pack_length(result->column_count, ptr);
con->packet_size= ((size_t)(ptr - start) - 4);
con->buffer_size+= (4 + con->packet_size);
/* Store packet size now. */
drizzle_set_byte3(start, con->packet_size);
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}

272
utils/mysqlcl_idb/row.cc
View File

@ -1,272 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <iostream>
#include <iomanip>
using namespace std;
/**
* @file
* @brief Row definitions
*/
#include <libdrizzle-2.0/common.h>
/*
* Client definitions
*/
uint64_t drizzle_row_read(drizzle_result_st *result, drizzle_return_t *ret_ptr)
{
if ((result->column_current != result->column_count) && (!(result->options & DRIZZLE_RESULT_BUFFER_COLUMN)))
{
drizzle_set_error(result->con->drizzle, "drizzle_row_read", "cannot retrieve rows until all columns are retrieved");
*ret_ptr= DRIZZLE_RETURN_NOT_READY;
return 0;
}
if (drizzle_state_none(result->con))
{
drizzle_state_push(result->con, drizzle_state_row_read);
drizzle_state_push(result->con, drizzle_state_packet_read);
}
*ret_ptr= drizzle_state_loop(result->con);
return result->row_current;
}
drizzle_row_t drizzle_row_buffer(drizzle_result_st *result,
drizzle_return_t *ret_ptr)
{
//cout<<"drizzle_row_buffer: 0x" << hex << (ptrdiff_t)result << endl;
size_t total;
drizzle_row_t row;
if (result == NULL)
{
return drizzle_row_t();
}
drizzle_return_t unused;
if (ret_ptr == NULL)
{
ret_ptr= &unused;
}
if (result->row == NULL)
{
if (drizzle_row_read(result, ret_ptr) == 0 || *ret_ptr != DRIZZLE_RETURN_OK)
{
return NULL;
}
result->row= new (std::nothrow) drizzle_row_t_type[result->column_count *2];
if (result->row == NULL)
{
*ret_ptr= DRIZZLE_RETURN_MEMORY;
return drizzle_row_t();
}
result->field_sizes= reinterpret_cast<size_t *>(result->row + result->column_count);
}
while (1)
{
drizzle_field_t field= drizzle_field_buffer(result, &total, ret_ptr);
if (*ret_ptr == DRIZZLE_RETURN_ROW_END)
{
break;
}
if (*ret_ptr != DRIZZLE_RETURN_OK)
{
if (*ret_ptr != DRIZZLE_RETURN_IO_WAIT)
{
delete[] result->row;
result->row= NULL;
result->field_sizes= NULL;
}
return NULL;
}
result->row[result->field_current - 1]= field;
result->field_sizes[result->field_current - 1]= total;
}
*ret_ptr= DRIZZLE_RETURN_OK;
row= result->row;
result->row= NULL;
return row;
}
void drizzle_row_free(drizzle_result_st *result, drizzle_row_t row)
{
uint16_t x;
for (x= 0; x < result->column_count; x++)
drizzle_field_free(row[x]);
delete[] row;
}
size_t *drizzle_row_field_sizes(drizzle_result_st *result)
{
return result->field_sizes;
}
drizzle_row_t drizzle_row_next(drizzle_result_st *result)
{
if (result->row_current == result->row_count)
return NULL;
result->field_sizes= result->field_sizes_list->at(static_cast<size_t>(result->row_current));
result->row_current++;
return result->row_list->at(static_cast<size_t>(result->row_current) - 1);
}
drizzle_row_t drizzle_row_prev(drizzle_result_st *result)
{
if (result->row_current == 0)
return NULL;
result->row_current--;
result->field_sizes= result->field_sizes_list->at(static_cast<size_t>(result->row_current));
return result->row_list->at(static_cast<size_t>(result->row_current));
}
void drizzle_row_seek(drizzle_result_st *result, uint64_t row)
{
if (row <= result->row_count)
result->row_current= row;
}
drizzle_row_t drizzle_row_index(drizzle_result_st *result, uint64_t row)
{
if (row >= result->row_count)
return NULL;
return (*result->row_list)[static_cast<size_t>(row)];
}
uint64_t drizzle_row_current(drizzle_result_st *result)
{
return result->row_current;
}
/*
* Server definitions
*/
drizzle_return_t drizzle_row_write(drizzle_result_st *result)
{
if (drizzle_state_none(result->con))
drizzle_state_push(result->con, drizzle_state_row_write);
return drizzle_state_loop(result->con);
}
/*
* Internal state functions.
*/
drizzle_return_t drizzle_state_row_read(drizzle_con_st *con)
{
drizzle_log_debug(con->drizzle, "drizzle_state_row_read");
if (con->packet_size != 0 && con->buffer_size < con->packet_size &&
con->buffer_size < 5)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
if (con->packet_size == 5 && con->buffer_ptr[0] == 254)
{
/* Got EOF packet, no more rows. */
con->result->row_current= 0;
con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 1);
con->status= (drizzle_con_status_t)drizzle_get_byte2(con->buffer_ptr + 3);
con->buffer_ptr+= 5;
con->buffer_size-= 5;
}
else if (con->buffer_ptr[0] == 255)
{
drizzle_state_pop(con);
drizzle_state_push(con, drizzle_state_result_read);
return DRIZZLE_RETURN_OK;
}
else if (con->result->options & DRIZZLE_RESULT_ROW_BREAK)
{
con->result->options&= ~DRIZZLE_RESULT_ROW_BREAK;
}
else
{
con->result->row_count++;
con->result->row_current++;
con->result->field_current= 0;
}
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_row_write(drizzle_con_st *con)
{
uint8_t *start= con->buffer_ptr + con->buffer_size;
drizzle_log_debug(con->drizzle, "drizzle_state_row_write");
/* Flush buffer if there is not enough room. */
if (((size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer)) < 4)
{
drizzle_state_push(con, drizzle_state_write);
return DRIZZLE_RETURN_OK;
}
drizzle_set_byte3(start, con->packet_size);
start[3]= con->packet_number;
con->packet_number++;
con->buffer_size+= 4;
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}

179
utils/mysqlcl_idb/sha1.cc
View File

@ -1,179 +0,0 @@
/**
* @file
* @brief SHA1 Definitions
*/
/*
* SHA-1 in C
*
* Copyright (C) 2010 nobody (this is public domain)
*
* This file is based on public domain code.
* Initial source code is in the public domain,
* so clarified by Steve Reid <steve@edmweb.com>
*
* Test Vectors (from FIPS PUB 180-1)
* "abc"
* A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
* "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
* 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
* A million repetitions of "a"
* 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
*/
#include <libdrizzle-2.0/common.h>
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
/*
* blk0() and blk() perform the initial expand.
* I got the idea of expanding during the round function from SSLeay
*/
#ifndef WORDS_BIGENDIAN
# define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
|(rol(block->l[i],8)&0x00FF00FF))
#else
# define blk0(i) block->l[i]
#endif
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
^block->l[(i+2)&15]^block->l[i&15],1))
/*
* (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
*/
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
/*
* Hash a single 512-bit block. This is the core of the algorithm.
*/
void
SHA1Transform(uint32_t state[5], const uint8_t buffer[SHA1_BLOCK_LENGTH])
{
uint32_t a, b, c, d, e;
typedef union {
uint8_t c[64];
uint32_t l[16];
} CHAR64LONG16;
CHAR64LONG16 realBlock;
CHAR64LONG16 *block= &realBlock;
(void)memcpy(block, buffer, SHA1_BLOCK_LENGTH);
/* Copy context->state[] to working vars */
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
/* 4 rounds of 20 operations each. Loop unrolled. */
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
/* Add the working vars back into context.state[] */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
/* Wipe variables */
a = b = c = d = e = 0;
}
/*
* SHA1Init - Initialize new context
*/
void
SHA1Init(SHA1_CTX *context)
{
/* SHA1 initialization constants */
context->count = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
context->state[4] = 0xC3D2E1F0;
}
/*
* Run your data through this.
*/
void
SHA1Update(SHA1_CTX *context, const uint8_t *data, size_t len)
{
size_t i, j;
j = (size_t)((context->count >> 3) & 63);
context->count += (len << 3);
if ((j + len) > 63) {
(void)memcpy(&context->buffer[j], data, (i = 64-j));
SHA1Transform(context->state, context->buffer);
for ( ; i + 63 < len; i += 64)
SHA1Transform(context->state, (uint8_t *)&data[i]);
j = 0;
} else {
i = 0;
}
(void)memcpy(&context->buffer[j], &data[i], len - i);
}
/*
* Add padding and return the message digest.
*/
void
SHA1Pad(SHA1_CTX *context)
{
uint8_t finalcount[8];
u_int i;
for (i = 0; i < 8; i++) {
finalcount[i] = (uint8_t)((context->count >>
((7 - (i & 7)) * 8)) & 255); /* Endian independent */
}
SHA1Update(context, (uint8_t *)"\200", 1);
while ((context->count & 504) != 448)
SHA1Update(context, (uint8_t *)"\0", 1);
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
}
void
SHA1Final(uint8_t digest[SHA1_DIGEST_LENGTH], SHA1_CTX *context)
{
u_int i;
SHA1Pad(context);
if (digest) {
for (i = 0; i < SHA1_DIGEST_LENGTH; i++) {
digest[i] = (uint8_t)
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
}
memset(context, 0, sizeof(*context));
}
}

100
utils/mysqlcl_idb/state.cc
View File

@ -1,100 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @file
* @brief State machine definitions
*/
#include <libdrizzle-2.0/common.h>
drizzle_return_t drizzle_state_loop(drizzle_con_st *con)
{
while (drizzle_state_none(con) == false)
{
drizzle_return_t ret= con->state_stack[con->state_current - 1](con);
if (ret != DRIZZLE_RETURN_OK)
{
if (ret != DRIZZLE_RETURN_IO_WAIT && ret != DRIZZLE_RETURN_PAUSE &&
ret != DRIZZLE_RETURN_ERROR_CODE)
{
drizzle_con_close(con);
}
return ret;
}
}
return DRIZZLE_RETURN_OK;
}
drizzle_return_t drizzle_state_packet_read(drizzle_con_st *con)
{
drizzle_log_debug(con->drizzle, "drizzle_state_packet_read");
if (con->buffer_size < 4)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
con->packet_size= drizzle_get_byte3(con->buffer_ptr);
if (con->buffer_size < con->packet_size + 4)
{
drizzle_state_push(con, drizzle_state_read);
return DRIZZLE_RETURN_OK;
}
if (con->packet_number != con->buffer_ptr[3])
{
drizzle_set_error(con->drizzle, "drizzle_state_packet_read",
"bad packet number:%u:%u", con->packet_number,
con->buffer_ptr[3]);
return DRIZZLE_RETURN_BAD_PACKET_NUMBER;
}
drizzle_log_debug(con->drizzle, "packet_size= %zu, packet_number= %u",
con->packet_size, con->packet_number);
con->packet_number++;
con->buffer_ptr+= 4;
con->buffer_size-= 4;
drizzle_state_pop(con);
return DRIZZLE_RETURN_OK;
}

122
utils/mysqlcl_idb/tdriver-works.cpp
View File

@ -1,122 +0,0 @@
/*
* Drizzle Client & Protocol Library
*
* Copyright (C) 2008 Eric Day (eday@oddments.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * The names of its contributors may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <cstdlib>
#include <cstring>
#include <getopt.h>
#include <iostream>
#include <libdrizzle-2.0/libdrizzle.hpp>
#include <netdb.h>
#include <unistd.h>
using namespace std;
int main(int argc, char *argv[])
{
const char* host= NULL;
const char* user= NULL;
const char* password= NULL;
in_port_t port= 0;
for (int c; (c = getopt(argc, argv, "d:h:mp:u:P:q:v")) != -1; )
{
switch (c)
{
case 'h':
host= optarg;
break;
case 'p':
port= static_cast<in_port_t>(atoi(optarg));
break;
case 'u':
user= optarg;
break;
case 'P':
password = optarg;
break;
default:
cout <<
"usage:\n"
"\t-h <host> - Host to connect to\n"
"\t-p <port> - Port to connect to\n"
"\t-u <user> - User\n"
"\t-P <pass> - Password\n";
return 1;
}
}
host="127.0.0.1";
port=13306;
user="rjd";
password="";
drizzle::drizzle_c drizzle;
drizzle_set_verbose((drizzle_st*)drizzle, DRIZZLE_VERBOSE_DEBUG);
drizzle::connection_c* con= new drizzle::connection_c(drizzle);
if (host || port)
con->set_tcp(host, port);
if (user || password)
con->set_auth(user, password);
//con->set_db("information_schema");
//drizzle::query_c q(*con, "select table_schema, table_name from tables where table_name like ?");
con->set_db("tpch1");
drizzle::query_c q(*con, "select n_nationkey from nation");
//q.p("%");
try
{
drizzle::result_c result= q.execute();
cout << q.read() << endl;
while (drizzle_row_t row= result.row_next())
{
for (int x= 0; x < result.column_count(); x++)
{
if (x)
cout << ", ";
cout << (row[x] ? row[x] : "NULL");
}
cout << endl;
}
}
catch (const drizzle::bad_query& e)
{
cerr << e.what() << endl;
return 1;
}
return 0;
}

114
utils/mysqlcl_idb/tdriver.cpp
View File

@ -1,114 +0,0 @@
#include <iostream>
//#define NDEBUG
#include <cassert>
using namespace std;
#include "libdrizzle-2.0/drizzle.h"
#include "libdrizzle-2.0/drizzle_client.h"
namespace
{
int doit()
{
drizzle_st* drzp=0;
drzp = drizzle_create();
assert(drzp);
//drizzle_set_verbose(drzp, DRIZZLE_VERBOSE_DEBUG);
drizzle_con_st* drzcp=0;
drzcp = drizzle_con_add_tcp(drzp, "127.0.0.1", 13306, "rjd", "", "tpch1", DRIZZLE_CON_MYSQL);
drizzle_return_t drztr;
drztr = drizzle_con_connect(drzcp);
assert(drztr==0);
//const char* query = "select * from nation";
const char* query = "select * from region";
drizzle_return_t* drztrp=0;
drztrp = &drztr;
drizzle_result_st* drzrp=0;
//drzrp=drizzle_result_create(drzcp);
//assert(drzrp);
drzrp = drizzle_query_str(drzcp, drzrp, query, drztrp);
assert(drzrp);
cout << "return_t = " << drztr << endl;
drztr = drizzle_result_buffer(drzrp);
cout << "return_t = " << drztr << endl;
drizzle_row_t row;
row = drizzle_row_next(drzrp);
while (row)
{
//cout << "got row: " << row[0] << ',' << row[1] << ',' << row[2] << '.' << row[3] << endl;
cout << "got row: " << row[0] << ',' << row[1] << ',' << row[2] << endl;
//drizzle_row_free(drzrp, row);
row = drizzle_row_next(drzrp);
}
drizzle_result_free(drzrp);
drzrp = 0;
drizzle_con_close(drzcp);
drizzle_con_free(drzcp);
drzcp = 0;
drizzle_free(drzp);
drzp = 0;
return 0;
}
int insertit()
{
drizzle_st* drzp=0;
drzp = drizzle_create();
assert(drzp);
//drizzle_set_verbose(drzp, DRIZZLE_VERBOSE_DEBUG);
drizzle_con_st* drzcp=0;
drzcp = drizzle_con_add_tcp(drzp, "127.0.0.1", 13306, "rjd", "", "tpch1", DRIZZLE_CON_MYSQL);
drizzle_return_t drztr;
drztr = drizzle_con_connect(drzcp);
assert(drztr==0);
//const char* query = "select * from nation";
const char* query = "insert into foo values (1)";
drizzle_return_t* drztrp=0;
drztrp = &drztr;
drizzle_result_st* drzrp=0;
//drzrp=drizzle_result_create(drzcp);
//assert(drzrp);
drzrp = drizzle_query_str(drzcp, drzrp, query, drztrp);
assert(drzrp);
cout << "return_t = " << drztr << endl;
drztr = drizzle_result_buffer(drzrp);
cout << "return_t = " << drztr << endl;
drizzle_result_free(drzrp);
drzrp = 0;
drizzle_con_close(drzcp);
drizzle_con_free(drzcp);
drzcp = 0;
drizzle_free(drzp);
drzp = 0;
return 0;
}
}
int main(int argc, char** argv)
{
doit();
//doit();
//doit();
//doit();
insertit();
return 0;
}

53
utils/mysqlcl_idb/tdriver1.cpp
View File

@ -1,53 +0,0 @@
#include <iostream>
//#define NDEBUG
#include <cassert>
using namespace std;
#include "libdrizzle-2.0/drizzle.h"
#include "libdrizzle-2.0/drizzle_client.h"
int main(int argc, char** argv)
{
drizzle_st* drzp=0;
drzp = drizzle_create();
assert(drzp);
drizzle_set_verbose(drzp, DRIZZLE_VERBOSE_DEBUG);
drizzle_con_st* drzcp=0;
drzcp = drizzle_con_create(drzp);
assert(drzcp);
//drizzle_con_add_tcp(drzp, "127.0.0.1", 13306, "rjd", "", "tpch1", DRIZZLE_CON_MYSQL);
drizzle_con_set_tcp(drzcp, "127.0.0.1", 13306);
drizzle_con_set_auth(drzcp, "rjd", "");
drizzle_con_set_db(drzcp, "tpch1");
drizzle_con_add_options(drzcp, DRIZZLE_CON_MYSQL);
drizzle_con_connect(drzcp);
drizzle_result_st* drzrp=0;
drzrp = drizzle_result_create(drzcp);
assert(drzrp);
const char* query = "select n_nationkey from nation";
drizzle_return_t drztr;
drizzle_return_t* drztrp=0;
drztrp = &drztr;
drzrp = drizzle_query_str(drzcp, drzrp, query, drztrp);
assert(drzrp);
cout << "return_t = " << drztr << endl;
uint64_t nrows=0;
nrows = drizzle_row_read(drzrp, drztrp);
cout << "return_t = " << drztr << endl;
cout << "rows returned = " << nrows << endl;
nrows = drizzle_result_row_count(drzrp);
cout << "rows returned = " << nrows << endl;
drizzle_con_close(drzcp);
return 0;
}

2
utils/querystats/CMakeLists.txt
View File

@ -8,6 +8,8 @@ set(querystats_LIB_SRCS querystats.cpp)
add_library(querystats SHARED ${querystats_LIB_SRCS})
target_link_libraries(querystats -L${SERVER_SOURCE_ROOT_DIR}/libmysql/ libmysqlclient_r.so)
set_target_properties(querystats PROPERTIES VERSION 1.0.0 SOVERSION 1)
install(TARGETS querystats DESTINATION ${ENGINE_LIBDIR} COMPONENT libs)

91
utils/querystats/querystats.cpp
View File

@ -21,6 +21,8 @@
*
***********************************************************************/
#include <my_config.h>
#include <mysql.h>
#include <string>
using namespace std;
@ -37,28 +39,24 @@ using namespace logging;
#include "querystats.h"
#include "libdrizzle-2.0/drizzle.h"
#include "libdrizzle-2.0/drizzle_client.h"
namespace querystats
{
const string SCHEMA = "infinidb_querystats";
struct IDB_Drizzle
struct IDB_MySQL
{
IDB_Drizzle(): drzp(NULL), drzcp(NULL), drzrp(NULL) {}
~IDB_Drizzle()
IDB_MySQL(): fCon(NULL), fRes(NULL) {}
~IDB_MySQL()
{
// The following API all checks NULL in the implementation.
drizzle_result_free(drzrp);
drizzle_con_close(drzcp);
drizzle_con_free(drzcp);
drizzle_free(drzp);
if (fRes)
mysql_free_result(fRes);
if (fCon)
mysql_close(fCon);
}
drizzle_st* drzp;
drizzle_con_st* drzcp;
drizzle_result_st* drzrp;
MYSQL* fCon;
MYSQL_RES* fRes;
};
QueryStats::QueryStats()
@ -206,25 +204,19 @@ void QueryStats::insert()
ERR_CROSS_ENGINE_CONFIG);
// insert stats to querystats table
IDB_Drizzle drizzle;
IDB_MySQL mysql;
drizzle.drzp = drizzle_create();
if (drizzle.drzp == 0)
mysql.fCon = mysql_init(NULL);
if (mysql.fCon == NULL)
handleMySqlError("fatal error initializing querystats lib", -1);
drizzle.drzcp = drizzle_con_add_tcp(drizzle.drzp, host.c_str(), port, user.c_str(), pwd.c_str(),
SCHEMA.c_str(), DRIZZLE_CON_MYSQL);
if (drizzle.drzcp == 0)
handleMySqlError("fatal error setting up parms in querystats lib", -1);
drizzle_return_t drzret;
drzret = drizzle_con_connect(drizzle.drzcp);
if (drzret != 0)
handleMySqlError("fatal error connecting to InfiniDB in querystats lib", drzret);
if (mysql_real_connect(mysql.fCon, host.c_str(), user.c_str(), pwd.c_str(),
SCHEMA.c_str(), port, NULL, 0) == NULL)
handleMySqlError("fatal error setting up parms in querystats lib", mysql_errno(mysql.fCon));
// escape quote characters
boost::scoped_array<char> query(new char[fQuery.length()*2+1]);
drizzle_escape_string(query.get(), fQuery.length()*2, fQuery.c_str(), fQuery.length());
mysql_real_escape_string(mysql.fCon, query.get(), fQuery.c_str(), fQuery.length());
ostringstream insert;
insert << "insert delayed into querystats values (0, ";
@ -248,14 +240,10 @@ void QueryStats::insert()
insert << fBlocksChanged << ", ";
insert << fNumFiles << ", ";
insert << fFileBytes << ")"; // the last 2 fields are not populated yet
drizzle.drzrp = drizzle_query_str(drizzle.drzcp, drizzle.drzrp, insert.str().c_str(), &drzret);
if (drzret != 0 || drizzle.drzrp == 0)
handleMySqlError("fatal error executing query in querystats lib", drzret);
drzret = drizzle_result_buffer(drizzle.drzrp);
if (drzret != 0)
handleMySqlError("fatal error reading results from InfiniDB in querystats lib", drzret);
int ret = mysql_query(mysql.fCon, insert.str().c_str());
if (ret != 0)
handleMySqlError("fatal error executing query in querystats lib", ret);
}
void QueryStats::handleMySqlError(const char* errStr, unsigned int errCode)
@ -294,19 +282,14 @@ uint32_t QueryStats::userPriority(string _host, const string _user)
ERR_CROSS_ENGINE_CONFIG);
// get user priority
IDB_Drizzle drizzle;
drizzle.drzp = drizzle_create();
if (drizzle.drzp == 0)
IDB_MySQL mysql;
mysql.fCon = mysql_init(NULL);
if (mysql.fCon == NULL)
handleMySqlError("fatal error initializing querystats lib", -1);
drizzle.drzcp = drizzle_con_add_tcp(drizzle.drzp, host.c_str(), port, user.c_str(), pwd.c_str(),
SCHEMA.c_str(), DRIZZLE_CON_MYSQL);
if (drizzle.drzcp == 0)
handleMySqlError("fatal error setting up parms in querystats lib", -1);
drizzle_return_t drzret;
drzret = drizzle_con_connect(drizzle.drzcp);
if (drzret != 0)
handleMySqlError("fatal error connecting to InfiniDB in querystats lib", drzret);
if (mysql_real_connect(mysql.fCon, host.c_str(), user.c_str(), pwd.c_str(),
SCHEMA.c_str(), port, NULL, 0) == NULL)
handleMySqlError("fatal error connecting to InfiniDB in querystats lib", mysql_errno(mysql.fCon));
// get the part of host string befor ':' if there is.
size_t pos = _host.find(':', 0);
@ -324,16 +307,18 @@ uint32_t QueryStats::userPriority(string _host, const string _user)
<< _user
<< "') and upper(a.priority) = upper(b.priority)";
drizzle.drzrp = drizzle_query_str(drizzle.drzcp, drizzle.drzrp, query.str().c_str(), &drzret);
if (drzret != 0 || drizzle.drzrp == 0)
handleMySqlError("fatal error executing query in querystats lib", drzret);
drzret = drizzle_result_buffer(drizzle.drzrp);
if (drzret != 0)
handleMySqlError("fatal error reading results from InfiniDB in querystats lib", drzret);
int ret =mysql_query(mysql.fCon, query.str().c_str());
if (ret != 0)
handleMySqlError("fatal error executing query in querystats lib", ret);
// Using mysql_store_result here as for mysql_use_result we would need to get every row
// Maybe limit 1 on the query in the future?
mysql.fRes = mysql_store_result(mysql.fCon);
if (mysql.fRes == NULL)
handleMySqlError("fatal error reading results from InfiniDB in querystats lib", mysql_errno(mysql.fCon));
// only fetch one row. if duplicate user name in the table, the first one will be got.
drizzle_row_t row;
row = drizzle_row_next(drizzle.drzrp);
MYSQL_ROW row;
row = mysql_fetch_row(mysql.fRes);
if (row)
{
fPriority = row[0];