~drizzle-trunk/drizzle/development : contents of libdrizzle/handshake.c at revision 1859.1.2

~drizzle-trunk/drizzle/development : (revision 1859.1.2)

/*
 * Drizzle Client & Protocol Library
 *
 * Copyright (C) 2008 Eric Day (eday@oddments.org)
 * All rights reserved.
 *
 * Use and distribution licensed under the BSD license.  See
 * the COPYING.BSD file in the root source directory for full text.
 */

/**
 * @file
 * @brief Handshake Definitions
 */

#include "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;

  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;
  }

  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= 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_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;

  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= 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 db string. */
  if ((34 + strlen(con->user) + scramble_size) == con->packet_size)
    con->db[0]= 0;
  else
  {
    ptr= 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",
                        "db 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->db[0]= 0;
      con->buffer_ptr++;
    }
    else
    {
      strncpy(con->db, (char *)con->buffer_ptr, DRIZZLE_MAX_DB_SIZE);
      con->db[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;
  drizzle_capabilities_t capabilities;
  drizzle_return_t ret;

  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->db) + 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;

  capabilities&= ~(DRIZZLE_CAPABILITIES_COMPRESS | DRIZZLE_CAPABILITIES_SSL);
  if (con->db[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;

  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_return_t ret;
  drizzle_result_st result;

  drizzle_log_debug(con->drizzle, "drizzle_state_handshake_result_read");

  if (drizzle_result_create(con, &result) == NULL)
    return DRIZZLE_RETURN_MEMORY;

  con->result= &result;

  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;
}

1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	1	/*
	2	* Drizzle Client & Protocol Library
	3	*
	4	* Copyright (C) 2008 Eric Day (eday@oddments.org)
	5	* All rights reserved.
	6	*
	7	* Use and distribution licensed under the BSD license. See
1799.2.3 by Monty Taylor Reference root BSD copying file.	8	* the COPYING.BSD file in the root source directory for full text.
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	9	*/
	10
	11	/**
	12	* @file
	13	* @brief Handshake Definitions
	14	*/
	15
	16	#include "common.h"
	17
	18	/*
	19	* Client Definitions
	20	*/
	21
	22	drizzle_return_t drizzle_handshake_server_read(drizzle_con_st *con)
	23	{
	24	if (drizzle_state_none(con))
	25	{
	26	drizzle_state_push(con, drizzle_state_handshake_server_read);
	27	drizzle_state_push(con, drizzle_state_packet_read);
	28	}
	29
	30	return drizzle_state_loop(con);
	31	}
	32
	33	drizzle_return_t drizzle_handshake_client_write(drizzle_con_st *con)
	34	{
	35	if (drizzle_state_none(con))
	36	{
	37	drizzle_state_push(con, drizzle_state_write);
	38	drizzle_state_push(con, drizzle_state_handshake_client_write);
	39	}
	40
	41	return drizzle_state_loop(con);
	42	}
	43
	44	/*
	45	* Server Definitions
	46	*/
	47
	48	drizzle_return_t drizzle_handshake_server_write(drizzle_con_st *con)
	49	{
	50	if (drizzle_state_none(con))
	51	{
	52	drizzle_state_push(con, drizzle_state_write);
	53	drizzle_state_push(con, drizzle_state_handshake_server_write);
	54	}
	55
	56	return drizzle_state_loop(con);
	57	}
	58
	59	drizzle_return_t drizzle_handshake_client_read(drizzle_con_st *con)
	60	{
	61	if (drizzle_state_none(con))
	62	{
	63	drizzle_state_push(con, drizzle_state_handshake_client_read);
	64	drizzle_state_push(con, drizzle_state_packet_read);
	65	}
	66
	67	return drizzle_state_loop(con);
	68	}
	69
	70	/*
	71	* State Definitions
	72	*/
73
74	drizzle_return_t drizzle_state_handshake_server_read(drizzle_con_st *con)
75	{
76	uint8_t *ptr;
77
78	drizzle_log_debug(con->drizzle, "drizzle_state_handshake_server_read");
79
80	/* Assume the entire handshake packet will fit in the buffer. */
81	if (con->buffer_size < con->packet_size)
82	{
83	drizzle_state_push(con, drizzle_state_read);
84	return DRIZZLE_RETURN_OK;
85	}
86
87	if (con->packet_size < 46)
88	{
89	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
90	"bad packet size:>=46:%zu", con->packet_size);
91	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
92	}
93
94	con->protocol_version= con->buffer_ptr[0];
95	con->buffer_ptr++;
96
97	if (con->protocol_version != 10)
98	{
99	/* This is a special case where the server determines that authentication
100	will be impossible and denies any attempt right away. */
101	if (con->protocol_version == 255)
102	{
103	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
104	"%.*s", (int32_t)con->packet_size - 3,
105	con->buffer_ptr + 2);
106	return DRIZZLE_RETURN_AUTH_FAILED;
107	}
108
109	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
110	"protocol version not supported:%d",
111	con->protocol_version);
112	return DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED;
113	}
114
115	/* Look for null-terminated server version string. */
116	ptr= memchr(con->buffer_ptr, 0, con->buffer_size - 1);
117	if (ptr == NULL)
118	{
119	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
120	"server version string not found");
121	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
122	}
123
124	if (con->packet_size != (46 + (size_t)(ptr - con->buffer_ptr)))
125	{
126	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
127	"bad packet size:%zu:%zu",
128	(46 + (size_t)(ptr - con->buffer_ptr)), con->packet_size);
129	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
130	}
131
132	strncpy(con->server_version, (char *)con->buffer_ptr,
133	DRIZZLE_MAX_SERVER_VERSION_SIZE);
134	con->server_version[DRIZZLE_MAX_SERVER_VERSION_SIZE - 1]= 0;
135	con->buffer_ptr+= ((ptr - con->buffer_ptr) + 1);
136
137	con->thread_id= (uint32_t)drizzle_get_byte4(con->buffer_ptr);
138	con->buffer_ptr+= 4;
139
140	con->scramble= con->scramble_buffer;
141	memcpy(con->scramble, con->buffer_ptr, 8);
142	/* Skip scramble and filler. */
143	con->buffer_ptr+= 9;
144
145	/* Even though drizzle_capabilities is more than 2 bytes, the protocol only
146	allows for 2. This means some capabilities are not possible during this
147	handshake step. The options beyond 2 bytes are for client response only. */
148	con->capabilities= (drizzle_capabilities_t)drizzle_get_byte2(con->buffer_ptr);
149	con->buffer_ptr+= 2;
150
151	if (con->options & DRIZZLE_CON_MYSQL &&
152	!(con->capabilities & DRIZZLE_CAPABILITIES_PROTOCOL_41))
153	{
154	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
155	"protocol version not supported, must be MySQL 4.1+");
156	return DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED;
157	}
158
159	con->charset= con->buffer_ptr[0];
160	con->buffer_ptr+= 1;
161
162	con->status= drizzle_get_byte2(con->buffer_ptr);
163	/* Skip status and filler. */
164	con->buffer_ptr+= 15;
165
166	memcpy(con->scramble + 8, con->buffer_ptr, 12);
167	con->buffer_ptr+= 13;
168
169	con->buffer_size-= con->packet_size;
170	if (con->buffer_size != 0)
171	{
172	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_read",
173	"unexpected data after packet:%zu", con->buffer_size);
174	return DRIZZLE_RETURN_UNEXPECTED_DATA;
175	}
176
177	con->buffer_ptr= con->buffer;
178
179	drizzle_state_pop(con);
180
181	if (!(con->options & DRIZZLE_CON_RAW_PACKET))
182	{
183	drizzle_state_push(con, drizzle_state_handshake_result_read);
184	drizzle_state_push(con, drizzle_state_packet_read);
185	drizzle_state_push(con, drizzle_state_write);
186	drizzle_state_push(con, drizzle_state_handshake_client_write);
187	}
188
189	return DRIZZLE_RETURN_OK;
190	}
191
192	drizzle_return_t drizzle_state_handshake_server_write(drizzle_con_st *con)
193	{
194	uint8_t *ptr;
195
196	drizzle_log_debug(con->drizzle, "drizzle_state_handshake_server_write");
197
198	/* Calculate max packet size. */
199	con->packet_size= 1 /* Protocol version */
200	+ strlen(con->server_version) + 1
201	+ 4 /* Thread ID */
202	+ 8 /* Scramble */
203	+ 1 /* NULL */
204	+ 2 /* Capabilities */
205	+ 1 /* Language */
206	+ 2 /* Status */
207	+ 13 /* Unused */
208	+ 12 /* Scramble */
209	+ 1; /* NULL */
210
211	/* Assume the entire handshake packet will fit in the buffer. */
212	if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
213	{
214	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_write",
215	"buffer too small:%zu", con->packet_size + 4);
216	return DRIZZLE_RETURN_INTERNAL_ERROR;
217	}
218
219	ptr= con->buffer_ptr;
220
221	/* Store packet size and packet number first. */
222	drizzle_set_byte3(ptr, con->packet_size);
223	ptr[3]= 0;
224	con->packet_number= 1;
225	ptr+= 4;
226
227	ptr[0]= con->protocol_version;
228	ptr++;
229
230	memcpy(ptr, con->server_version, strlen(con->server_version));
231	ptr+= strlen(con->server_version);
232
233	ptr[0]= 0;
234	ptr++;
235
236	drizzle_set_byte4(ptr, con->thread_id);
237	ptr+= 4;
238
239	if (con->scramble == NULL)
240	memset(ptr, 0, 8);
241	else
242	memcpy(ptr, con->scramble, 8);
243	ptr+= 8;
244
245	ptr[0]= 0;
246	ptr++;
247
248	if (con->options & DRIZZLE_CON_MYSQL)
249	con->capabilities\|= DRIZZLE_CAPABILITIES_PROTOCOL_41;
250
251	/* We can only send two bytes worth, this is a protocol limitation. */
252	drizzle_set_byte2(ptr, con->capabilities);
253	ptr+= 2;
254
255	ptr[0]= con->charset;
256	ptr++;
257
258	drizzle_set_byte2(ptr, con->status);
259	ptr+= 2;
260
261	memset(ptr, 0, 13);
262	ptr+= 13;
263
264	if (con->scramble == NULL)
265	memset(ptr, 0, 12);
266	else
267	memcpy(ptr, con->scramble + 8, 12);
268	ptr+= 12;
269
270	ptr[0]= 0;
271	ptr++;
272
273	con->buffer_size+= (4 + con->packet_size);
274
275	/* Make sure we packed it correctly. */
276	if ((size_t)(ptr - con->buffer_ptr) != (4 + con->packet_size))
277	{
278	drizzle_set_error(con->drizzle, "drizzle_state_handshake_server_write",
279	"error packing server handshake:%zu:%zu",
280	(size_t)(ptr - con->buffer_ptr), 4 + con->packet_size);
281	return DRIZZLE_RETURN_INTERNAL_ERROR;
282	}
283
284	drizzle_state_pop(con);
285	return DRIZZLE_RETURN_OK;
286	}
287
288	drizzle_return_t drizzle_state_handshake_client_read(drizzle_con_st *con)
289	{
290	size_t real_size;
291	uint8_t *ptr;
292	uint8_t scramble_size;
293
294	drizzle_log_debug(con->drizzle, "drizzle_state_handshake_client_read");
295
296	/* Assume the entire handshake packet will fit in the buffer. */
297	if (con->buffer_size < con->packet_size)
298	{
299	drizzle_state_push(con, drizzle_state_read);
300	return DRIZZLE_RETURN_OK;
301	}
302
303	/* This is the minimum packet size. */
304	if (con->packet_size < 34)
305	{
306	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
307	"bad packet size:>=34:%zu", con->packet_size);
308	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
309	}
310
311	real_size= 34;
312
313	con->capabilities= drizzle_get_byte4(con->buffer_ptr);
314	con->buffer_ptr+= 4;
315
316	if (con->options & DRIZZLE_CON_MYSQL &&
317	!(con->capabilities & DRIZZLE_CAPABILITIES_PROTOCOL_41))
318	{
319	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
320	"protocol version not supported, must be MySQL 4.1+");
321	return DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED;
322	}
323
324	con->max_packet_size= (uint32_t)drizzle_get_byte4(con->buffer_ptr);
325	con->buffer_ptr+= 4;
326
327	con->charset= con->buffer_ptr[0];
328	con->buffer_ptr+= 1;
329
330	/* Skip unused. */
331	con->buffer_ptr+= 23;
332
333	/* Look for null-terminated user string. */
334	ptr= memchr(con->buffer_ptr, 0, con->buffer_size - 32);
335	if (ptr == NULL)
336	{
337	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
338	"user string not found");
339	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
340	}
341
342	if (con->buffer_ptr == ptr)
343	{
344	con->user[0]= 0;
345	con->buffer_ptr++;
346	}
347	else
348	{
349	real_size+= (size_t)(ptr - con->buffer_ptr);
350	if (con->packet_size < real_size)
351	{
352	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
353	"bad packet size:>=%zu:%zu", real_size,
354	con->packet_size);
355	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
356	}
357
358	strncpy(con->user, (char *)con->buffer_ptr, DRIZZLE_MAX_USER_SIZE);
359	con->user[DRIZZLE_MAX_USER_SIZE - 1]= 0;
360	con->buffer_ptr+= ((ptr - con->buffer_ptr) + 1);
361	}
362
363	scramble_size= con->buffer_ptr[0];
364	con->buffer_ptr+= 1;
365
366	if (scramble_size == 0)
367	con->scramble= NULL;
368	else
369	{
370	if (scramble_size != DRIZZLE_MAX_SCRAMBLE_SIZE)
371	{
372	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
373	"wrong scramble size");
374	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
375	}
376
377	real_size+= scramble_size;
378	con->scramble= con->scramble_buffer;
379	memcpy(con->scramble, con->buffer_ptr, DRIZZLE_MAX_SCRAMBLE_SIZE);
380
381	con->buffer_ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
382	}
383
384	/* Look for null-terminated db string. */
385	if ((34 + strlen(con->user) + scramble_size) == con->packet_size)
386	con->db[0]= 0;
387	else
388	{
389	ptr= memchr(con->buffer_ptr, 0, con->buffer_size -
390	(34 + strlen(con->user) + scramble_size));
391	if (ptr == NULL)
392	{
393	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
394	"db string not found");
395	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
396	}
397
398	real_size+= ((size_t)(ptr - con->buffer_ptr) + 1);
399	if (con->packet_size != real_size)
400	{
401	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
402	"bad packet size:%zu:%zu", real_size, con->packet_size);
403	return DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET;
404	}
405
406	if (con->buffer_ptr == ptr)
407	{
408	con->db[0]= 0;
409	con->buffer_ptr++;
410	}
411	else
412	{
413	strncpy(con->db, (char *)con->buffer_ptr, DRIZZLE_MAX_DB_SIZE);
414	con->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
415	con->buffer_ptr+= ((ptr - con->buffer_ptr) + 1);
416	}
417	}
418
419	con->buffer_size-= con->packet_size;
420	if (con->buffer_size != 0)
421	{
422	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_read",
423	"unexpected data after packet:%zu", con->buffer_size);
424	return DRIZZLE_RETURN_UNEXPECTED_DATA;
425	}
426
427	con->buffer_ptr= con->buffer;
428
429	drizzle_state_pop(con);
430	return DRIZZLE_RETURN_OK;
431	}
432
433	drizzle_return_t drizzle_state_handshake_client_write(drizzle_con_st *con)
434	{
435	uint8_t *ptr;
436	drizzle_capabilities_t capabilities;
437	drizzle_return_t ret;
438
439	drizzle_log_debug(con->drizzle, "drizzle_state_handshake_client_write");
440
441	/* Calculate max packet size. */
442	con->packet_size= 4 /* Capabilities */
443	+ 4 /* Max packet size */
444	+ 1 /* Charset */
445	+ 23 /* Unused */
446	+ strlen(con->user) + 1
447	+ 1 /* Scramble size */
448	+ DRIZZLE_MAX_SCRAMBLE_SIZE
449	+ strlen(con->db) + 1;
450
451	/* Assume the entire handshake packet will fit in the buffer. */
452	if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
453	{
454	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_write",
455	"buffer too small:%zu", con->packet_size + 4);
456	return DRIZZLE_RETURN_INTERNAL_ERROR;
457	}
458
459	ptr= con->buffer_ptr;
460
461	/* Store packet size at the end since it may change. */
462	ptr[3]= con->packet_number;
463	con->packet_number++;
464	ptr+= 4;
465
466	if (con->options & DRIZZLE_CON_MYSQL)
467	con->capabilities\|= DRIZZLE_CAPABILITIES_PROTOCOL_41;
468
469	capabilities= con->capabilities & DRIZZLE_CAPABILITIES_CLIENT;
470	if (!(con->options & DRIZZLE_CON_FOUND_ROWS))
471	capabilities&= ~DRIZZLE_CAPABILITIES_FOUND_ROWS;
472
473	capabilities&= ~(DRIZZLE_CAPABILITIES_COMPRESS \| DRIZZLE_CAPABILITIES_SSL);
474	if (con->db[0] == 0)
475	capabilities&= ~DRIZZLE_CAPABILITIES_CONNECT_WITH_DB;
476
477	drizzle_set_byte4(ptr, capabilities);
478	ptr+= 4;
479
480	drizzle_set_byte4(ptr, con->max_packet_size);
481	ptr+= 4;
482
483	ptr[0]= con->charset;
484	ptr++;
485
486	memset(ptr, 0, 23);
487	ptr+= 23;
488
489	ptr= drizzle_pack_auth(con, ptr, &ret);
490	if (ret != DRIZZLE_RETURN_OK)
491	return ret;
492
493	con->buffer_size+= (4 + con->packet_size);
494
495	/* Make sure we packed it correctly. */
496	if ((size_t)(ptr - con->buffer_ptr) != (4 + con->packet_size))
497	{
498	drizzle_set_error(con->drizzle, "drizzle_state_handshake_client_write",
499	"error packing client handshake:%zu:%zu",
500	(size_t)(ptr - con->buffer_ptr), 4 + con->packet_size);
501	return DRIZZLE_RETURN_INTERNAL_ERROR;
502	}
503
504	/* Store packet size now. */
505	drizzle_set_byte3(con->buffer_ptr, con->packet_size);
506
507	drizzle_state_pop(con);
508	return DRIZZLE_RETURN_OK;
509	}
510
511	drizzle_return_t drizzle_state_handshake_result_read(drizzle_con_st *con)
512	{
513	drizzle_return_t ret;
514	drizzle_result_st result;
515
516	drizzle_log_debug(con->drizzle, "drizzle_state_handshake_result_read");
517
518	if (drizzle_result_create(con, &result) == NULL)
519	return DRIZZLE_RETURN_MEMORY;
520
521	con->result= &result;
522
523	ret= drizzle_state_result_read(con);
524	if (drizzle_state_none(con))
525	{
526	if (ret == DRIZZLE_RETURN_OK)
527	{
528	if (drizzle_result_eof(&result))
529	{
530	drizzle_set_error(con->drizzle, "drizzle_state_handshake_result_read",
531	"old insecure authentication mechanism not supported");
532	ret= DRIZZLE_RETURN_AUTH_FAILED;
533	}
534	else
535	con->options\|= DRIZZLE_CON_READY;
536	}
537	}
538
539	drizzle_result_free(&result);
540
541	if (ret == DRIZZLE_RETURN_ERROR_CODE)
542	return DRIZZLE_RETURN_HANDSHAKE_FAILED;
543
544	return ret;
545	}