keks-overlay.git

@@ -1,31 +0,0 @@

-AUX mysql-5/mysql.erl 26950 RMD160 1e7f78cfc3165270f49e5f9a5b0991abfcd19750 SHA1 a45d087613aa0556cddffcec6ebc97547415eec8 SHA256 56da9d145b8d8fc08bbec5569aaa6ac58c852f2bb163ead1b448cb263edf290c size 26950

-MD5 6468ce139782e5afdc174814ef79e3dc files/mysql-5/mysql.erl 26950

-RMD160 1e7f78cfc3165270f49e5f9a5b0991abfcd19750 files/mysql-5/mysql.erl 26950

-SHA256 56da9d145b8d8fc08bbec5569aaa6ac58c852f2bb163ead1b448cb263edf290c files/mysql-5/mysql.erl 26950

-AUX mysql-5/mysql.hrl 105 RMD160 e87df112cee2b8cd8e40f48ebd33cc9ad5824c85 SHA1 5756564c95b85c6913917b715b682f01cf1ae652 SHA256 7913a92afb56c909cef29f9ee57f8483c7acc2de484909c3165dd7abb8951996 size 105

-MD5 2a911311bafd83b0b7837de8046b4035 files/mysql-5/mysql.hrl 105

-RMD160 e87df112cee2b8cd8e40f48ebd33cc9ad5824c85 files/mysql-5/mysql.hrl 105

-SHA256 7913a92afb56c909cef29f9ee57f8483c7acc2de484909c3165dd7abb8951996 files/mysql-5/mysql.hrl 105

-AUX mysql-5/mysql_auth.erl 6578 RMD160 91ab61b647c0e671fc47432f66340e262ef42b23 SHA1 3b4094be6995f9438246c204dabecaa8cf82d667 SHA256 ca13c4177a4acb13d4e4eb3fb31e132996477a4a526aa50fc42851fac2288d85 size 6578

-MD5 b12048d5b64c0249173d8a0d690dbdd3 files/mysql-5/mysql_auth.erl 6578

-RMD160 91ab61b647c0e671fc47432f66340e262ef42b23 files/mysql-5/mysql_auth.erl 6578

-SHA256 ca13c4177a4acb13d4e4eb3fb31e132996477a4a526aa50fc42851fac2288d85 files/mysql-5/mysql_auth.erl 6578

-AUX mysql-5/mysql_conn.erl 24318 RMD160 5bd5c430553245285b45a8f33bc8a438b2b75f03 SHA1 9ac62dea95ff209dbc27b54c74a74df4868c04c5 SHA256 93b8d6029682e1f9dd5343b78639c209201513ad4da0e6a4e010680c545a027f size 24318

-MD5 d62886a6d354e54867c2fa925ecfbf5b files/mysql-5/mysql_conn.erl 24318

-RMD160 5bd5c430553245285b45a8f33bc8a438b2b75f03 files/mysql-5/mysql_conn.erl 24318

-SHA256 93b8d6029682e1f9dd5343b78639c209201513ad4da0e6a4e010680c545a027f files/mysql-5/mysql_conn.erl 24318

-AUX mysql-5/mysql_recv.erl 5969 RMD160 55e05e77eea577cd97f646dbbaa4a59d6170b90d SHA1 b00e10ec0aa0f6686e86a0a33e24fff6e543b5a8 SHA256 22069257ff8230bb2b8f26c7e065a5d6f6c0b5f4f2bf5d505830ffe2b75ce783 size 5969

-MD5 c4e1b577553658ec96e1a867a7091d14 files/mysql-5/mysql_recv.erl 5969

-RMD160 55e05e77eea577cd97f646dbbaa4a59d6170b90d files/mysql-5/mysql_recv.erl 5969

-SHA256 22069257ff8230bb2b8f26c7e065a5d6f6c0b5f4f2bf5d505830ffe2b75ce783 files/mysql-5/mysql_recv.erl 5969

-EBUILD mysql-5.ebuild 677 RMD160 4a3c3ef182ed4104587fbbbf0f2f438efac02eee SHA1 e0f02ae13504ebff9ff76818ed15776a742e1d6b SHA256 bcfc02741dad9bab768b61f63399e333bcc5bc28944b9e8a6da6c5411cc86cc4 size 677

-MD5 6ac678b1fdfdb88c7d89dca2204019d0 mysql-5.ebuild 677

-RMD160 4a3c3ef182ed4104587fbbbf0f2f438efac02eee mysql-5.ebuild 677

-SHA256 bcfc02741dad9bab768b61f63399e333bcc5bc28944b9e8a6da6c5411cc86cc4 mysql-5.ebuild 677

-MISC ChangeLog 215 RMD160 e0efaa0907544feb0bed5176d09cc613ab5ac6ec SHA1 18c3589897fc9c0a61b67c4c7f94cbe147104ab1 SHA256 fbdc6b0fd128a03a62490ca8db778d8a7c1d255b8819339d291887d40440140a size 215

-MD5 b0c339ed8db8a4512f1664a3d7915531 ChangeLog 215

-RMD160 e0efaa0907544feb0bed5176d09cc613ab5ac6ec ChangeLog 215

-SHA256 fbdc6b0fd128a03a62490ca8db778d8a7c1d255b8819339d291887d40440140a ChangeLog 215

-MD5 68b329da9893e34099c7d8ad5cb9c940 files/digest-mysql-5 1

-RMD160 c0da025038ed83c687ddc430da9846ecb97f3998 files/digest-mysql-5 1

-SHA256 01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b files/digest-mysql-5 1

@@ -1,656 +0,0 @@

-%%%-------------------------------------------------------------------

-%%% File    : mysql.erl

-%%% Author  : Magnus Ahltorp <ahltorp@nada.kth.se>

-%%% Descrip.: MySQL client.

-%%%

-%%% Created :  4 Aug 2005 by Magnus Ahltorp <ahltorp@nada.kth.se>

-%%%

-%%% Copyright (c) 2001-2004 Kungliga Tekniska H�gskolan

-%%% See the file COPYING

-%%%

-%%% Usage:

-%%%

-%%%

-%%% Call one of the start-functions before any call to fetch/2

-%%%

-%%%   start_link(Id, Host, User, Password, Database)

-%%%   start_link(Id, Host, Port, User, Password, Database)

-%%%   start_link(Id, Host, User, Password, Database, LogFun)

-%%%   start_link(Id, Host, Port, User, Password, Database, LogFun)

-%%%

-%%% Id is a connection group identifier. If you want to have more

-%%% than one connection to a server (or a set of MySQL replicas),

-%%% add more with

-%%%

-%%%   connect(Id, Host, Port, User, Password, Database, Reconnect)

-%%%

-%%% use 'undefined' as Port to get default MySQL port number (3306).

-%%% MySQL querys will be sent in a per-Id round-robin fashion.

-%%% Set Reconnect to 'true' if you want the dispatcher to try and

-%%% open a new connection, should this one die.

-%%%

-%%% When you have a mysql_dispatcher running, this is how you make a

-%%% query :

-%%%

-%%%   fetch(Id, "select * from hello") -> Result

-%%%     Result = {data, MySQLRes} | {updated, MySQLRes} |

-%%%              {error, MySQLRes}

-%%%

-%%% Actual data can be extracted from MySQLRes by calling the following API

-%%% functions:

-%%%     - on data received:

-%%%          FieldInfo = mysql:get_result_field_info(MysqlRes)

-%%%          AllRows   = mysql:get_result_rows(MysqlRes)

-%%%         with FieldInfo = list() of {Table, Field, Length, Name}

-%%%          and AllRows   = list() of list() representing records

-%%%     - on update:

-%%%          Affected  = mysql:get_result_affected_rows(MysqlRes)

-%%%         with Affected  = integer()

-%%%     - on error:

-%%%          Reason    = mysql:get_result_reason(MysqlRes)

-%%%         with Reason    = string()

-%%% 

-%%% If you just want a single MySQL connection, or want to manage your

-%%% connections yourself, you can use the mysql_conn module as a

-%%% stand-alone single MySQL connection. See the comment at the top of

-%%% mysql_conn.erl.

-%%%

-%%%-------------------------------------------------------------------

--module(mysql).

-

--behaviour(gen_server).

-

-%%--------------------------------------------------------------------

-%% External exports

-%%--------------------------------------------------------------------

--export([start_link/5,

-	 start_link/6,

-	 start_link/7,

-

-	 fetch/2,

-	 fetch/3,

-

-	 get_result_field_info/1,

-	 get_result_rows/1,

-	 get_result_affected_rows/1,

-	 get_result_reason/1,

-

-	 quote/1,

-	 asciz_binary/2,

-

-	 connect/7

-	]).

-

-%%--------------------------------------------------------------------

-%% Internal exports - just for mysql_* modules

-%%--------------------------------------------------------------------

--export([log/3,

-	 log/4

-	]).

-

-%%--------------------------------------------------------------------

-%% Internal exports - gen_server callbacks

-%%--------------------------------------------------------------------

--export([init/1,

-	 handle_call/3,

-	 handle_cast/2,

-	 handle_info/2,

-	 terminate/2,

-	 code_change/3

-	]).

-

-%%--------------------------------------------------------------------

-%% Records

-%%--------------------------------------------------------------------

--include("mysql.hrl").

--record(state, {

-	  conn_list,	%% list() of mysql_connection record()

-	  log_fun	%% undefined | function for logging,

-	 }).

-

--record(mysql_connection, {

-	  id,		%% term(), user of 'mysql' modules id of this socket group

-	  conn_pid,	%% pid(), mysql_conn process

-	  reconnect,	%% true | false, should mysql_dispatcher try to reconnect if this connection dies?

-	  host,		%% undefined | string()

-	  port,		%% undefined | integer()

-	  user,		%% undefined | string()

-	  password,	%% undefined | string()

-	  database	%% undefined | string()

-	 }).

-

-%%--------------------------------------------------------------------

-%% Macros

-%%--------------------------------------------------------------------

--define(SERVER, mysql_dispatcher).

--define(CONNECT_TIMEOUT, 5000).

--define(LOCAL_FILES, 128).

-

--define(PORT, 3306).

-

-

-%%====================================================================

-%% External functions

-%%====================================================================

-

-%%--------------------------------------------------------------------

-%% Function: start_link(Id, Host, User, Password, Database)

-%%           start_link(Id, Host, Port, User, Password, Database)

-%%           start_link(Id, Host, User, Password, Database, LogFun)

-%%           start_link(Id, Host, Port, User, Password, Database,

-%%                      LogFun)

-%%           Id       = term(), first connection-group Id

-%%           Host     = string()

-%%           Port     = integer()

-%%           User     = string()

-%%           Password = string()

-%%           Database = string()

-%%           LogFun   = undefined | function() of arity 3

-%% Descrip.: Starts the MySQL client gen_server process.

-%% Returns : {ok, Pid} | ignore | {error, Error}

-%%--------------------------------------------------------------------

-start_link(Id, Host, User, Password, Database) when is_list(Host), is_list(User), is_list(Password),

-						    is_list(Database) ->

-    start_link(Id, Host, ?PORT, User, Password, Database, undefined).

-

-start_link(Id, Host, Port, User, Password, Database) when is_list(Host), is_integer(Port), is_list(User),

-							  is_list(Password), is_list(Database) ->

-    start_link(Id, Host, Port, User, Password, Database, undefined);

-

-start_link(Id, Host, User, Password, Database, LogFun) when is_list(Host), is_list(User), is_list(Password),

-							    is_list(Database) ->

-    start_link(Id, Host, ?PORT, User, Password, Database, LogFun).

-

-start_link(Id, Host, Port, User, Password, Database, LogFun) when is_list(Host), is_integer(Port), is_list(User),

-								  is_list(Password), is_list(Database) ->

-    crypto:start(),

-    gen_server:start_link({local, ?SERVER}, ?MODULE, [Id, Host, Port, User, Password, Database, LogFun], []).

-

-%%--------------------------------------------------------------------

-%% Function: fetch(Id, Query)

-%%           fetch(Id, Query, Timeout)

-%%           Id      = term(), connection-group Id

-%%           Query   = string(), MySQL query in verbatim

-%%           Timeout = integer() | infinity, gen_server timeout value

-%% Descrip.: Send a query and wait for the result.

-%% Returns : {data, MySQLRes}    |

-%%           {updated, MySQLRes} | 

-%%           {error, MySQLRes}

-%%           MySQLRes = term()

-%%--------------------------------------------------------------------

-fetch(Id, Query) when is_list(Query) ->

-    gen_server:call(?SERVER, {fetch, Id, Query}).

-fetch(Id, Query, Timeout) when is_list(Query) ->

-    gen_server:call(?SERVER, {fetch, Id, Query}, Timeout).

-

-%%--------------------------------------------------------------------

-%% Function: get_result_field_info(MySQLRes)

-%%           MySQLRes = term(), result of fetch function on "data"

-%% Descrip.: Extract the FieldInfo from MySQL Result on data received

-%% Returns : FieldInfo

-%%           FieldInfo = list() of {Table, Field, Length, Name}

-%%--------------------------------------------------------------------

-get_result_field_info(#mysql_result{fieldinfo = FieldInfo}) ->

-    FieldInfo.

-

-%%--------------------------------------------------------------------

-%% Function: get_result_rows(MySQLRes)

-%%           MySQLRes = term(), result of fetch function on "data"

-%% Descrip.: Extract the Rows from MySQL Result on data received

-%% Returns : Rows

-%%           Rows = list() of list() representing records

-%%--------------------------------------------------------------------

-get_result_rows(#mysql_result{rows=AllRows}) ->

-    AllRows.

-

-%%--------------------------------------------------------------------

-%% Function: get_result_affected_rows(MySQLRes)

-%%           MySQLRes = term(), result of fetch function on "updated"

-%% Descrip.: Extract the Rows from MySQL Result on update

-%% Returns : AffectedRows

-%%           AffectedRows = integer()

-%%--------------------------------------------------------------------

-get_result_affected_rows(#mysql_result{affectedrows=AffectedRows}) ->

-    AffectedRows.

-

-%%--------------------------------------------------------------------

-%% Function: get_result_reason(MySQLRes)

-%%           MySQLRes = term(), result of fetch function on "error"

-%% Descrip.: Extract the error Reason from MySQL Result on error

-%% Returns : Reason

-%%           Reason    = string()

-%%--------------------------------------------------------------------

-get_result_reason(#mysql_result{error=Reason}) ->

-    Reason.

-

-%%--------------------------------------------------------------------

-%% Function: quote(String)

-%%           String = string()

-%% Descrip.: Quote a string so that it can be included safely in a

-%%           MySQL query.

-%% Returns : Quoted = string()

-%%--------------------------------------------------------------------

-quote(String) when is_list(String) ->

-    [34 | lists:reverse([34 | quote(String, [])])].	%% 34 is $"

-

-quote([], Acc) ->

-    Acc;

-quote([0 | Rest], Acc) ->

-    quote(Rest, [$0, $\\ | Acc]);

-quote([10 | Rest], Acc) ->

-    quote(Rest, [$n, $\\ | Acc]);

-quote([13 | Rest], Acc) ->

-    quote(Rest, [$r, $\\ | Acc]);

-quote([$\\ | Rest], Acc) ->

-    quote(Rest, [$\\ , $\\ | Acc]);

-quote([39 | Rest], Acc) ->		%% 39 is $'

-    quote(Rest, [39, $\\ | Acc]);	%% 39 is $'

-quote([34 | Rest], Acc) ->		%% 34 is $"

-    quote(Rest, [34, $\\ | Acc]);	%% 34 is $"

-quote([26 | Rest], Acc) ->

-    quote(Rest, [$Z, $\\ | Acc]);

-quote([C | Rest], Acc) ->

-    quote(Rest, [C | Acc]).

-

-%%--------------------------------------------------------------------

-%% Function: asciz_binary(Data, Acc)

-%%           Data = binary()

-%%           Acc  = list(), input accumulator

-%% Descrip.: Find the first zero-byte in Data and add everything

-%%           before it to Acc, as a string.

-%% Returns : {NewList, Rest}

-%%           NewList = list(), Acc plus what we extracted from Data

-%%           Rest    = binary(), whatever was left of Data, not

-%%                     including the zero-byte

-%%--------------------------------------------------------------------

-asciz_binary(<<>>, Acc) ->

-    {lists:reverse(Acc), <<>>};

-asciz_binary(<<0:8, Rest/binary>>, Acc) ->

-    {lists:reverse(Acc), Rest};

-asciz_binary(<<C:8, Rest/binary>>, Acc) ->

-    asciz_binary(Rest, [C | Acc]).

-

-%%--------------------------------------------------------------------

-%% Function: connect(Id, Host, Port, User, Password, Database,

-%%                   Reconnect)

-%%           Id        = term(), connection-group Id

-%%           Host      = string()

-%%           Port      = undefined | integer()

-%%           User      = string()

-%%           Password  = string()

-%%           Database  = string()

-%%           Reconnect = true | false

-%% Descrip.: Starts a MySQL connection and, if successfull, registers

-%%           it with the mysql_dispatcher.

-%% Returns : {ok, ConnPid} | {error, Reason}

-%%--------------------------------------------------------------------

-connect(Id, Host, undefined, User, Password, Database, Reconnect) ->

-    connect(Id, Host, ?PORT, User, Password, Database, Reconnect);

-connect(Id, Host, Port, User, Password, Database, Reconnect) ->

-    {ok, LogFun} = gen_server:call(?SERVER, get_logfun),

-    case mysql_conn:start(Host, Port, User, Password, Database, LogFun) of

-	{ok, ConnPid} ->

-	    MysqlConn =

-		case Reconnect of

-		    true ->

-			#mysql_connection{id        = Id,

-					  conn_pid  = ConnPid,

-					  reconnect = true,

-					  host      = Host,

-					  port      = Port,

-					  user      = User,

-					  password  = Password,

-					  database  = Database

-					 };

-		    false ->

-			#mysql_connection{id        = Id,

-					  conn_pid  = ConnPid,

-					  reconnect = false

-					 }

-		end,

-	    case gen_server:call(?SERVER, {add_mysql_connection, MysqlConn}) of

-		ok ->

-		    {ok, ConnPid};

-		Res ->

-		    Res

-	    end;

-	{error, Reason} ->

-	    {error, Reason}

-    end.

-

-%%--------------------------------------------------------------------

-%% Function: log(LogFun, Level, Format)

-%%           log(LogFun, Level, Format, Arguments)

-%%           LogFun    = undefined | function() with arity 3

-%%           Level     = debug | normal | error

-%%           Format    = string()

-%%           Arguments = list() of term()

-%% Descrip.: Either call the function LogFun with the Level, Format

-%%           and Arguments as parameters or log it to the console if

-%%           LogFun is undefined.

-%% Returns : void()

-%%

-%% Note    : Exported only for use by the mysql_* modules.

-%%

-%%--------------------------------------------------------------------

-log(LogFun, Level, Format) ->

-    log(LogFun, Level, Format, []).

-

-log(LogFun, Level, Format, Arguments) when is_function(LogFun) ->

-    LogFun(Level, Format, Arguments);

-log(undefined, _Level, Format, Arguments) ->

-    %% default is to log to console

-    io:format(Format, Arguments),

-    io:format("~n", []).

-

-

-%%====================================================================

-%% gen_server callbacks

-%%====================================================================

-

-%%--------------------------------------------------------------------

-%% Function: init(Args) -> {ok, State} |

-%%                         {ok, State, Timeout} |

-%%                         ignore               |

-%%                         {stop, Reason}

-%%           Args = [Id, Host, Port, User, Password, Database, LogFun]

-%%             Id       = term(), connection-group Id

-%%             Host     = string()

-%%             Port     = integer()

-%%             User     = string()

-%%             Password = string()

-%%             Database = string()

-%%             LogFun   = undefined | function() with arity 3

-%% Descrip.: Initiates the gen_server (MySQL dispatcher).

-%%--------------------------------------------------------------------

-init([Id, Host, Port, User, Password, Database, LogFun]) ->

-    case mysql_conn:start(Host, Port, User, Password, Database, LogFun) of

-	{ok, ConnPid} ->

-	    MysqlConn = #mysql_connection{id        = Id,

-					  conn_pid  = ConnPid,

-					  reconnect = true,

-					  host	    = Host,

-					  port      = Port,

-					  user      = User,

-					  password  = Password,

-					  database  = Database

-					 },

-	    case add_mysql_conn(MysqlConn, []) of

-		{ok, ConnList} ->

-		    {ok, #state{log_fun    = LogFun,

-				conn_list = ConnList

-			       }};

-		error ->

-		    Msg = "mysql: Failed adding first MySQL connection handler to my list, exiting",

-		    log(LogFun, error, Msg),

-		    {error, Msg}

-	    end;

-	{error, Reason} ->

-	    log(LogFun, error, "mysql: Failed starting first MySQL connection handler, exiting"),

-	    {stop, {error, Reason}}

-    end.

-

-%%--------------------------------------------------------------------

-%% Function: handle_call(Msg, From, State)

-%% Descrip.: Handling call messages.

-%% Returns : {reply, Reply, State}          |

-%%           {reply, Reply, State, Timeout} |

-%%           {noreply, State}               |

-%%           {noreply, State, Timeout}      |

-%%           {stop, Reason, Reply, State}   | (terminate/2 is called)

-%%           {stop, Reason, State}            (terminate/2 is called)

-%%--------------------------------------------------------------------

-

-

-%%--------------------------------------------------------------------

-%% Function: handle_call({fetch, Id, Query}, From, State)

-%%           Id    = term(), connection-group id

-%%           Query = string(), MySQL query

-%% Descrip.: Make a MySQL query. Use the first connection matching Id

-%%           in our connection-list. Don't block the mysql_dispatcher

-%%           by returning {noreply, ...} here and let the mysql_conn

-%%           do gen_server:reply(...) when it has an answer.

-%% Returns : {noreply, NewState}             |

-%%           {reply, {error, Reason}, State}

-%%           NewState = state record()

-%%           Reason   = atom() | string()

-%%--------------------------------------------------------------------

-handle_call({fetch, Id, Query}, From, State) ->

-    log(State#state.log_fun, debug, "mysql: fetch ~p (id ~p)", [Query, Id]),

-    case get_next_mysql_connection_for_id(Id, State#state.conn_list) of

-	{ok, MysqlConn, RestOfConnList} when is_record(MysqlConn, mysql_connection) ->

-	    mysql_conn:fetch(MysqlConn#mysql_connection.conn_pid, Query, From),

-	    %% move this mysql socket to the back of the list

-	    NewConnList = RestOfConnList ++ [MysqlConn],

-	    %% The ConnPid process does a gen_server:reply() when it has an answer

-	    {noreply, State#state{conn_list = NewConnList}};

-	nomatch ->

-	    %% we have no active connection matching Id

-	    {reply, {error, no_connection}, State}

-    end;

-

-%%--------------------------------------------------------------------

-%% Function: handle_call({add_mysql_connection, Conn}, From, State)

-%%           Conn = mysql_connection record()

-%% Descrip.: Add Conn to our list of connections.

-%% Returns : {reply, Reply, NewState}

-%%           Reply = ok | {error, Reason}

-%%           NewState = state record()

-%%           Reason   = string()

-%%--------------------------------------------------------------------

-handle_call({add_mysql_connection, Conn}, _From, State) when is_record(Conn, mysql_connection) ->

-    case add_mysql_conn(Conn, State#state.conn_list) of

-	{ok, NewConnList} ->

-	    {Id, ConnPid} = {Conn#mysql_connection.id, Conn#mysql_connection.conn_pid},

-	    log(State#state.log_fun, normal, "mysql: Added connection with id '~p' (pid ~p) to my list",

-		[Id, ConnPid]),

-	    {reply, ok, State#state{conn_list = NewConnList}};

-	error ->

-	    {reply, {error, "failed adding MySQL connection to my list"}, State}

-    end;

-

-%%--------------------------------------------------------------------

-%% Function: handle_call(get_logfun, From, State)

-%% Descrip.: Fetch our logfun.

-%% Returns : {reply, {ok, LogFun}, State}

-%%           LogFun = undefined | function() with arity 3

-%%--------------------------------------------------------------------

-handle_call(get_logfun, _From, State) ->

-    {reply, {ok, State#state.log_fun}, State};

-

-handle_call(Unknown, _From, State) ->

-    log(State#state.log_fun, error, "mysql: Received unknown gen_server call : ~p", [Unknown]),

-    {reply, {error, "unknown gen_server call in mysql client"}, State}.

-

-

-%%--------------------------------------------------------------------

-%% Function: handle_cast(Msg, State)

-%% Descrip.: Handling cast messages

-%% Returns : {noreply, State}          |

-%%           {noreply, State, Timeout} |

-%%           {stop, Reason, State}            (terminate/2 is called)

-%%--------------------------------------------------------------------

-handle_cast(Unknown, State) ->

-    log(State#state.log_fun, error, "mysql: Received unknown gen_server cast : ~p", [Unknown]),

-    {noreply, State}.

-

-

-%%--------------------------------------------------------------------

-%% Function: handle_info(Msg, State)

-%% Descrip.: Handling all non call/cast messages

-%% Returns : {noreply, State}          |

-%%           {noreply, State, Timeout} |

-%%           {stop, Reason, State}            (terminate/2 is called)

-%%--------------------------------------------------------------------

-

-%%--------------------------------------------------------------------

-%% Function: handle_info({'DOWN', ...}, State)

-%% Descrip.: Handle a message that one of our monitored processes

-%%           (mysql_conn processes in our connection list) has exited.

-%%           Remove the entry from our list.

-%% Returns : {noreply, NewState}   |

-%%           {stop, normal, State}

-%%           NewState = state record()

-%%

-%% Note    : For now, we stop if our connection list becomes empty.

-%%           We should try to reconnect for a while first, to not

-%%           eventually stop the whole OTP application if the MySQL-

-%%           server is shut down and the mysql_dispatcher was super-

-%%           vised by an OTP supervisor.

-%%--------------------------------------------------------------------

-handle_info({'DOWN', _MonitorRef, process, Pid, Info}, State) ->

-    LogFun = State#state.log_fun,

-    case remove_mysql_connection_using_pid(Pid, State#state.conn_list, []) of

-	{ok, Conn, NewConnList} ->

-	    LogLevel = case Info of

-			   normal -> normal;

-			   _ -> error

-		       end,

-	    log(LogFun, LogLevel, "mysql: MySQL connection pid ~p exited : ~p", [Pid, Info]),

-	    log(LogFun, normal, "mysql: Removed MySQL connection with pid ~p from list",

-		[Pid]),

-	    case Conn#mysql_connection.reconnect of

-		true ->

-		    start_reconnect(Conn, LogFun);

-		false ->

-		    ok

-	    end,

-	    {noreply, State#state{conn_list = NewConnList}};

-	nomatch ->

-	    log(LogFun, error, "mysql: Received 'DOWN' signal from pid ~p not in my list", [Pid]),

-	    {noreply, State}

-    end;

-    

-handle_info(Info, State) ->

-    log(State#state.log_fun, error, "mysql: Received unknown signal : ~p", [Info]),

-    {noreply, State}.

-

-%%--------------------------------------------------------------------

-%% Function: terminate(Reason, State)

-%% Descrip.: Shutdown the server

-%% Returns : Reason

-%%--------------------------------------------------------------------

-terminate(Reason, State) ->

-    LogFun = State#state.log_fun,

-    LogLevel = case Reason of

-		   normal -> debug;

-		   _ -> error

-	       end,

-    log(LogFun, LogLevel, "mysql: Terminating with reason : ~p", [Reason]),

-    Reason.

-

-%%--------------------------------------------------------------------

-%% Function: code_change(_OldVsn, State, _Extra)

-%% Descrip.: Convert process state when code is changed

-%% Returns : {ok, State}

-%%--------------------------------------------------------------------

-code_change(_OldVsn, State, _Extra) ->

-    {ok, State}.

-

-%%====================================================================

-%% Internal functions

-%%====================================================================

-

-%%--------------------------------------------------------------------

-%% Function: add_mysql_conn(Conn, ConnList)

-%%           Conn     = mysql_connection record()

-%%           ConnList = list() of mysql_connection record()

-%% Descrip.: Set up process monitoring of the mysql_conn process and

-%%           then add it (first) to ConnList.

-%% Returns : NewConnList = list() of mysql_connection record()

-%%--------------------------------------------------------------------

-add_mysql_conn(Conn, ConnList) when is_record(Conn, mysql_connection), is_list(ConnList) ->

-    erlang:monitor(process, Conn#mysql_connection.conn_pid),

-    {ok, [Conn | ConnList]}.

-

-%%--------------------------------------------------------------------

-%% Function: remove_mysql_connection_using_pid(Pid, ConnList)

-%%           Pid      = pid()

-%%           ConnList = list() of mysql_connection record()

-%% Descrip.: Removes the first mysql_connection in ConnList that has

-%%           a pid matching Pid.

-%% Returns : {ok, Conn, NewConnList} | nomatch

-%%           Conn        = mysql_connection record()

-%%           NewConnList = list() of mysql_connection record()

-%%--------------------------------------------------------------------

-remove_mysql_connection_using_pid(Pid, [#mysql_connection{conn_pid = Pid} = H | T], Res) ->

-    {ok, H, lists:reverse(Res) ++ T};

-remove_mysql_connection_using_pid(Pid, [H | T], Res) when is_record(H, mysql_connection) ->

-    remove_mysql_connection_using_pid(Pid, T, [H | Res]);

-remove_mysql_connection_using_pid(_Pid, [], _Res) ->

-    nomatch.

-

-%%--------------------------------------------------------------------

-%% Function: get_next_mysql_connection_for_id(Id, ConnList)

-%%           Id       = term(), connection-group id

-%%           ConnList = list() of mysql_connection record()

-%% Descrip.: Find the first mysql_connection in ConnList that has an

-%%           id matching Id.

-%% Returns : {ok, Conn, NewConnList} | nomatch

-%%           Conn        = mysql_connection record()

-%%           NewConnList = list() of mysql_connection record(), same

-%%                         as ConnList but without Conn

-%%--------------------------------------------------------------------

-get_next_mysql_connection_for_id(Id, ConnList) ->

-    get_next_mysql_connection_for_id(Id, ConnList, []).

-

-get_next_mysql_connection_for_id(Id, [#mysql_connection{id = Id} = H | T], Res) ->

-    {ok, H, lists:reverse(Res) ++ T};

-get_next_mysql_connection_for_id(Id, [H | T], Res) when is_record(H, mysql_connection) ->

-    get_next_mysql_connection_for_id(Id, T, [H | Res]);

-get_next_mysql_connection_for_id(_Id, [], _Res) ->

-    nomatch.

-

-%%--------------------------------------------------------------------

-%% Function: start_reconnect(Conn, LogFun)

-%%           Conn   = mysql_connection record()

-%%           LogFun = undefined | function() with arity 3

-%% Descrip.: Spawns a process that will try to re-establish a new

-%%           connection instead of the one in Conn which has just

-%%           died.

-%% Returns : ok

-%%--------------------------------------------------------------------

-start_reconnect(Conn, LogFun) when is_record(Conn, mysql_connection) ->

-    Pid = spawn(fun () ->

-			reconnect_loop(Conn#mysql_connection{conn_pid = undefined}, LogFun, 0)

-		end),

-    {Id, Host, Port} = {Conn#mysql_connection.id, Conn#mysql_connection.host, Conn#mysql_connection.port},

-    log(LogFun, debug, "mysql: Started pid ~p to try and reconnect to ~p:~s:~p (replacing "

-	"connection with pid ~p)", [Pid, Id, Host, Port, Conn#mysql_connection.conn_pid]),

-    ok.

-

-%%--------------------------------------------------------------------

-%% Function: reconnect_loop(Conn, LogFun, 0)

-%%           Conn   = mysql_connection record()

-%%           LogFun = undefined | function() with arity 3

-%% Descrip.: Loop indefinately until we are able to reconnect to the

-%%           server specified in the now dead connection Conn.

-%% Returns : ok

-%%--------------------------------------------------------------------

-reconnect_loop(Conn, LogFun, N) when is_record(Conn, mysql_connection) ->

-    {Id, Host, Port} = {Conn#mysql_connection.id, Conn#mysql_connection.host, Conn#mysql_connection.port},

-    case connect(Id,

-		 Host,

-		 Port,

-		 Conn#mysql_connection.user,

-		 Conn#mysql_connection.password,

-		 Conn#mysql_connection.database,

-		 Conn#mysql_connection.reconnect) of

-	{ok, ConnPid} ->

-	    log(LogFun, debug, "mysql_reconnect: Managed to reconnect to ~p:~s:~p (connection pid ~p)",

-		[Id, Host, Port, ConnPid]),

-	    ok;

-	{error, Reason} ->

-	    %% log every once in a while

-	    NewN = case N of

-		       10 ->

-			   log(LogFun, debug, "mysql_reconnect: Still unable to connect to ~p:~s:~p (~p)",

-			       [Id, Host, Port, Reason]),

-			   0;

-		       _ ->

-			   N + 1

-		   end,

-	    %% sleep between every unsuccessfull attempt

-	    timer:sleep(20 * 1000),

-	    reconnect_loop(Conn, LogFun, NewN)

-    end.

@@ -1,6 +0,0 @@

-%% MySQL result record:

--record(mysql_result,

-	{fieldinfo=[],

-	 rows=[],

-	 affectedrows=0,

-	 error=""}).

@@ -1,189 +0,0 @@

-%%%-------------------------------------------------------------------

-%%% File    : mysql_auth.erl

-%%% Author  : Fredrik Thulin <ft@it.su.se>

-%%% Descrip.: MySQL client authentication functions.

-%%% Created :  4 Aug 2005 by Fredrik Thulin <ft@it.su.se>

-%%%

-%%% Note    : All MySQL code was written by Magnus Ahltorp, originally

-%%%           in the file mysql.erl - I just moved it here.

-%%%

-%%% Copyright (c) 2001-2004 Kungliga Tekniska H�gskolan

-%%% See the file COPYING

-%%%

-%%%-------------------------------------------------------------------

--module(mysql_auth).

-

-%%--------------------------------------------------------------------

-%% External exports (should only be used by the 'mysql_conn' module)

-%%--------------------------------------------------------------------

--export([

-	 do_old_auth/7,

-	 do_new_auth/8

-	]).

-

-%%--------------------------------------------------------------------

-%% Macros

-%%--------------------------------------------------------------------

--define(LONG_PASSWORD, 1).

--define(LONG_FLAG, 4).

--define(PROTOCOL_41, 512).

--define(TRANSACTIONS, 8192).

--define(SECURE_CONNECTION, 32768).

--define(CONNECT_WITH_DB, 8).

-

--define(MAX_PACKET_SIZE, 1000000).

-

-%%====================================================================

-%% External functions

-%%====================================================================

-

-%%--------------------------------------------------------------------

-%% Function: do_old_auth(Sock, RecvPid, SeqNum, User, Password, Salt1,

-%%                       LogFun)

-%%           Sock     = term(), gen_tcp socket

-%%           RecvPid  = pid(), receiver process pid

-%%           SeqNum   = integer(), first sequence number we should use

-%%           User     = string(), MySQL username

-%%           Password = string(), MySQL password

-%%           Salt1    = string(), salt 1 from server greeting

-%%           LogFun   = undefined | function() of arity 3

-%% Descrip.: Perform old-style MySQL authentication.

-%% Returns : result of mysql_conn:do_recv/3

-%%--------------------------------------------------------------------

-do_old_auth(Sock, RecvPid, SeqNum, User, Password, Salt1, LogFun) ->

-    Auth = password_old(Password, Salt1),

-    Packet2 = make_auth(User, Auth),

-    do_send(Sock, Packet2, SeqNum, LogFun),

-    mysql_conn:do_recv(LogFun, RecvPid, SeqNum).

-

-%%--------------------------------------------------------------------

-%% Function: do_new_auth(Sock, RecvPid, SeqNum, User, Password, Salt1,

-%%                       Salt2, LogFun)

-%%           Sock     = term(), gen_tcp socket

-%%           RecvPid  = pid(), receiver process pid

-%%           SeqNum   = integer(), first sequence number we should use

-%%           User     = string(), MySQL username

-%%           Password = string(), MySQL password

-%%           Salt1    = string(), salt 1 from server greeting

-%%           Salt2    = string(), salt 2 from server greeting

-%%           LogFun   = undefined | function() of arity 3

-%% Descrip.: Perform MySQL authentication.

-%% Returns : result of mysql_conn:do_recv/3

-%%--------------------------------------------------------------------

-do_new_auth(Sock, RecvPid, SeqNum, User, Password, Salt1, Salt2, LogFun) ->

-    Auth = password_new(Password, Salt1 ++ Salt2),

-    Packet2 = make_new_auth(User, Auth, none),

-    do_send(Sock, Packet2, SeqNum, LogFun),

-    case mysql_conn:do_recv(LogFun, RecvPid, SeqNum) of

-	{ok, Packet3, SeqNum2} ->

-	    case Packet3 of

-		<<254:8>> ->

-		    AuthOld = password_old(Password, Salt1),

-		    do_send(Sock, <<AuthOld/binary, 0:8>>, SeqNum2 + 1, LogFun),

-		    mysql_conn:do_recv(LogFun, RecvPid, SeqNum2 + 1);

-		_ ->

-		    {ok, Packet3, SeqNum2}

-	    end;

-	{error, Reason} ->

-	    {error, Reason}

-    end.

-

-%%====================================================================

-%% Internal functions

-%%====================================================================

-

-password_old(Password, Salt) ->

-    {P1, P2} = hash(Password),

-    {S1, S2} = hash(Salt),

-    Seed1 = P1 bxor S1,

-    Seed2 = P2 bxor S2,

-    List = rnd(9, Seed1, Seed2),

-    {L, [Extra]} = lists:split(8, List),

-    list_to_binary(lists:map(fun (E) ->

-				     E bxor (Extra - 64)

-			     end, L)).

-

-%% part of do_old_auth/4, which is part of mysql_init/4

-make_auth(User, Password) ->

-    Caps = ?LONG_PASSWORD bor ?LONG_FLAG bor ?TRANSACTIONS,

-    Maxsize = 0,

-    UserB = list_to_binary(User),

-    PasswordB = Password,

-    <<Caps:16/little, Maxsize:24/little, UserB/binary, 0:8,

-    PasswordB/binary>>.

-

-%% part of do_new_auth/4, which is part of mysql_init/4

-make_new_auth(User, Password, Database) ->

-    DBCaps = case Database of

-		 none ->

-		     0;

-		 _ ->

-		     ?CONNECT_WITH_DB

-	     end,

-    Caps = ?LONG_PASSWORD bor ?LONG_FLAG bor ?TRANSACTIONS bor

-	?PROTOCOL_41 bor ?SECURE_CONNECTION bor DBCaps,

-    Maxsize = ?MAX_PACKET_SIZE,

-    UserB = list_to_binary(User),

-    PasswordL = size(Password),

-    DatabaseB = case Database of

-		    none ->

-			<<>>;

-		    _ ->

-			list_to_binary(Database)

-		end,

-    <<Caps:32/little, Maxsize:32/little, 8:8, 0:23/integer-unit:8,

-    UserB/binary, 0:8, PasswordL:8, Password/binary, DatabaseB/binary>>.

-

-hash(S) ->

-    hash(S, 1345345333, 305419889, 7).

-

-hash([C | S], N1, N2, Add) ->

-    N1_1 = N1 bxor (((N1 band 63) + Add) * C + N1 * 256),

-    N2_1 = N2 + ((N2 * 256) bxor N1_1),

-    Add_1 = Add + C,

-    hash(S, N1_1, N2_1, Add_1);

-hash([], N1, N2, _Add) ->

-    Mask = (1 bsl 31) - 1,

-    {N1 band Mask , N2 band Mask}.

-

-rnd(N, Seed1, Seed2) ->

-    Mod = (1 bsl 30) - 1,

-    rnd(N, [], Seed1 rem Mod, Seed2 rem Mod).

-

-rnd(0, List, _, _) ->

-    lists:reverse(List);

-rnd(N, List, Seed1, Seed2) ->

-    Mod = (1 bsl 30) - 1,

-    NSeed1 = (Seed1 * 3 + Seed2) rem Mod,

-    NSeed2 = (NSeed1 + Seed2 + 33) rem Mod,

-    Float = (float(NSeed1) / float(Mod))*31,

-    Val = trunc(Float)+64,

-    rnd(N - 1, [Val | List], NSeed1, NSeed2).

-

-

-

-dualmap(_F, [], []) ->

-    [];

-dualmap(F, [E1 | R1], [E2 | R2]) ->

-    [F(E1, E2) | dualmap(F, R1, R2)].

-

-bxor_binary(B1, B2) ->

-    list_to_binary(dualmap(fun (E1, E2) ->

-				   E1 bxor E2

-			   end, binary_to_list(B1), binary_to_list(B2))).

-

-password_new(Password, Salt) ->

-    Stage1 = crypto:sha(Password),

-    Stage2 = crypto:sha(Stage1),

-    Res = crypto:sha_final(

-	    crypto:sha_update(

-	      crypto:sha_update(crypto:sha_init(), Salt),

-	      Stage2)

-	   ),

-    bxor_binary(Res, Stage1).

-

-

-do_send(Sock, Packet, Num, LogFun) ->

-    mysql:log(LogFun, debug, "mysql_auth send packet ~p: ~p", [Num, Packet]),

-    Data = <<(size(Packet)):24/little, Num:8, Packet/binary>>,

-    gen_tcp:send(Sock, Data).

@@ -1,620 +0,0 @@

-%%%-------------------------------------------------------------------

-%%% File    : mysql_conn.erl

-%%% Author  : Fredrik Thulin <ft@it.su.se>

-%%% Descrip.: MySQL connection handler, handles de-framing of messages

-%%%           received by the MySQL receiver process.

-%%% Created :  5 Aug 2005 by Fredrik Thulin <ft@it.su.se>

-%%% Modified: 11 Jan 2006 by Mickael Remond <mickael.remond@process-one.net>

-%%%

-%%% Note    : All MySQL code was written by Magnus Ahltorp, originally

-%%%           in the file mysql.erl - I just moved it here.

-%%%

-%%% Copyright (c) 2001-2004 Kungliga Tekniska H�gskolan

-%%% See the file COPYING

-%%%

-%%%

-%%% This module handles a single connection to a single MySQL server.

-%%% You can use it stand-alone, or through the 'mysql' module if you

-%%% want to have more than one connection to the server, or

-%%% connections to different servers.

-%%%

-%%% To use it stand-alone, set up the connection with

-%%%

-%%%   {ok, Pid} = mysql_conn:start(Host, Port, User, Password,

-%%%                                Database, LogFun)

-%%%

-%%%         Host     = string()

-%%%         Port     = integer()

-%%%         User     = string()

-%%%         Password = string()

-%%%         Database = string()

-%%%         LogFun   = undefined | (gives logging to console)

-%%%                    function() of arity 3 (Level, Fmt, Args)

-%%%

-%%% Note: In stand-alone mode you have to start Erlang crypto application by

-%%% yourself with crypto:start()

-%%%

-%%% and then make MySQL querys with

-%%%

-%%%   Result = mysql_conn:fetch(Pid, Query, self())

-%%%

-%%%         Result = {data, MySQLRes}    |

-%%%                  {updated, MySQLRes} |

-%%%                  {error, MySQLRes}

-%%%          Where: MySQLRes = #mysql_result

-%%%

-%%% Actual data can be extracted from MySQLRes by calling the following API

-%%% functions:

-%%%     - on data received:

-%%%          FieldInfo = mysql:get_result_field_info(MysqlRes)

-%%%          AllRows   = mysql:get_result_rows(MysqlRes)

-%%%         with FieldInfo = list() of {Table, Field, Length, Name}

-%%%          and AllRows = list() of list() representing records

-%%%     - on update:

-%%%          Affected= mysql:get_result_affected_rows(MysqlRes)

-%%%         with Affected = integer()

-%%%     - on error:

-%%%          Reason    = mysql:get_result_reason(MysqlRes)

-%%%         with Reason = string()

-%%%-------------------------------------------------------------------

-

--module(mysql_conn).

-

-%%--------------------------------------------------------------------

-%% External exports

-%%--------------------------------------------------------------------

--export([start/6,

-	 start_link/6,

-	 fetch/3,

-	 fetch/4

-	]).

-

-%%--------------------------------------------------------------------

-%% External exports (should only be used by the 'mysql_auth' module)

-%%--------------------------------------------------------------------

--export([do_recv/3

-	]).

-

--include("mysql.hrl").

--record(state, {

-	  mysql_version,

-	  log_fun,

-	  recv_pid,

-	  socket,

-	  data

-	 }).

-

--define(SECURE_CONNECTION, 32768).

--define(MYSQL_QUERY_OP, 3).

--define(DEFAULT_STANDALONE_TIMEOUT, 5000).

--define(MYSQL_4_0, 40). %% Support for MySQL 4.0.x

--define(MYSQL_4_1, 41). %% Support for MySQL 4.1.x et 5.0.x

-

-%%====================================================================

-%% External functions

-%%====================================================================

-

-%%--------------------------------------------------------------------

-%% Function: start(Host, Port, User, Password, Database, LogFun)

-%% Function: start_link(Host, Port, User, Password, Database, LogFun)

-%%           Host     = string()

-%%           Port     = integer()

-%%           User     = string()

-%%           Password = string()

-%%           Database = string()

-%%           LogFun   = undefined | function() of arity 3

-%% Descrip.: Starts a mysql_conn process that connects to a MySQL

-%%           server, logs in and chooses a database.

-%% Returns : {ok, Pid} | {error, Reason}

-%%           Pid    = pid()

-%%           Reason = string()

-%%--------------------------------------------------------------------

-start(Host, Port, User, Password, Database, LogFun) when is_list(Host), is_integer(Port), is_list(User),

-							 is_list(Password), is_list(Database) ->

-    ConnPid = self(),

-    Pid = spawn(fun () ->

-			init(Host, Port, User, Password, Database, LogFun, ConnPid)

-		end),

-    post_start(Pid, LogFun).

-

-start_link(Host, Port, User, Password, Database, LogFun) when is_list(Host), is_integer(Port), is_list(User),

-							 is_list(Password), is_list(Database) ->

-    ConnPid = self(),

-    Pid = spawn_link(fun () ->

-			init(Host, Port, User, Password, Database, LogFun, ConnPid)

-		end),

-    post_start(Pid, LogFun).

-

-%% part of start/6 or start_link/6:

-post_start(Pid, LogFun) ->

-    receive

-	{mysql_conn, Pid, ok} ->

-	    {ok, Pid};

-	{mysql_conn, Pid, {error, Reason}} ->

-	    {error, Reason};

-	Unknown ->

-	    mysql:log(LogFun, error, "mysql_conn: Received unknown signal, exiting"),

-	    mysql:log(LogFun, debug, "mysql_conn: Unknown signal : ~p", [Unknown]),

-	    {error, "unknown signal received"}

-    after 5000 ->

-	    {error, "timed out"}

-    end.

-

-%%--------------------------------------------------------------------

-%% Function: fetch(Pid, Query, From)

-%%           fetch(Pid, Query, From, Timeout)

-%%           Pid     = pid(), mysql_conn to send fetch-request to

-%%           Query   = string(), MySQL query in verbatim

-%%           From    = pid() or term(), use a From of self() when

-%%                     using this module for a single connection,

-%%                     or pass the gen_server:call/3 From argument if

-%%                     using a gen_server to do the querys (e.g. the

-%%                     mysql_dispatcher)

-%%           Timeout = integer() | infinity, gen_server timeout value

-%% Descrip.: Send a query and wait for the result if running stand-

-%%           alone (From = self()), but don't block the caller if we

-%%           are not running stand-alone (From = gen_server From).

-%% Returns : ok                        | (non-stand-alone mode)

-%%           {data, #mysql_result}     | (stand-alone mode)

-%%           {updated, #mysql_result}  | (stand-alone mode)

-%%           {error, #mysql_result}      (stand-alone mode)

-%%           FieldInfo = term()

-%%           Rows      = list() of [string()]

-%%           Reason    = term()

-%%--------------------------------------------------------------------

-fetch(Pid, Query, From) ->

-    fetch(Pid, Query, From, ?DEFAULT_STANDALONE_TIMEOUT).

-

-fetch(Pid, Query, From, Timeout) when is_pid(Pid), is_list(Query) ->

-    Self = self(),

-    Pid ! {fetch, Query, From},

-    case From of

-	Self ->

-	    %% We are not using a mysql_dispatcher, await the response

-	    receive

-		{fetch_result, Pid, Result} ->

-		    Result

-	    after Timeout ->

-		    {error, "query timed out"}

-	    end;

-	_ ->

-	    %% From is gen_server From, Pid will do gen_server:reply() when it has an answer

-	    ok

-    end.

-     

-%%--------------------------------------------------------------------

-%% Function: do_recv(LogFun, RecvPid, SeqNum)

-%%           LogFun  = undefined | function() with arity 3

-%%           RecvPid = pid(), mysql_recv process

-%%           SeqNum  = undefined | integer()

-%% Descrip.: Wait for a frame decoded and sent to us by RecvPid.

-%%           Either wait for a specific frame if SeqNum is an integer,

-%%           or just any frame if SeqNum is undefined.

-%% Returns : {ok, Packet, Num} |

-%%           {error, Reason}

-%%           Reason = term()

-%%

-%% Note    : Only to be used externally by the 'mysql_auth' module.

-%%--------------------------------------------------------------------

-do_recv(LogFun, RecvPid, SeqNum) when is_function(LogFun); LogFun == undefined, SeqNum == undefined ->

-    receive

-        {mysql_recv, RecvPid, data, Packet, Num} ->

-            %%mysql:log(LogFun, debug, "mysql_conn: recv packet ~p: ~p", [Num, Packet]),

-	    {ok, Packet, Num};

-	{mysql_recv, RecvPid, closed, _E} ->

-	    {error, "mysql_recv: socket was closed"}

-    end;

-do_recv(LogFun, RecvPid, SeqNum) when is_function(LogFun); LogFun == undefined, is_integer(SeqNum) ->

-    ResponseNum = SeqNum + 1,

-    receive

-        {mysql_recv, RecvPid, data, Packet, ResponseNum} ->

-            %%mysql:log(LogFun, debug, "mysql_conn: recv packet ~p: ~p", [ResponseNum, Packet]),

-	    {ok, Packet, ResponseNum};

-	{mysql_recv, RecvPid, closed, _E} ->

-	    {error, "mysql_recv: socket was closed"}

-        end.

-

-

-%%====================================================================

-%% Internal functions

-%%====================================================================

-

-%%--------------------------------------------------------------------

-%% Function: init(Host, Port, User, Password, Database, LogFun,

-%%                Parent)

-%%           Host     = string()

-%%           Port     = integer()

-%%           User     = string()

-%%           Password = string()

-%%           Database = string()

-%%           LogFun   = undefined | function() of arity 3

-%%           Parent   = pid() of process starting this mysql_conn

-%% Descrip.: Connect to a MySQL server, log in and chooses a database.

-%%           Report result of this to Parent, and then enter loop() if

-%%           we were successfull.

-%% Returns : void() | does not return

-%%--------------------------------------------------------------------