~drizzle-trunk/drizzle/development : contents of examples/sqlite

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

/*
 * 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.
 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>

#include <libdrizzle/drizzle_server.h>
#include <sqlite3.h>

#define SQLITE_SERVER_VERSION "SQLite Server using libdrizzle 0.1"

#define DRIZZLE_RETURN_CHECK(__ret, __function, __drizzle) \
{ \
  if ((__ret) != DRIZZLE_RETURN_OK) \
    DRIZZLE_RETURN_ERROR(__function, __drizzle) \
}

#define DRIZZLE_RETURN_ERROR(__function, __drizzle) \
{ \
  printf(__function ":%s\n", drizzle_error(__drizzle)); \
  return; \
}

#define DRIZZLE_RETURN_CHECK_VAL(__ret, __function, __drizzle) \
{ \
  if ((__ret) != DRIZZLE_RETURN_OK) \
  { \
    printf(__function ":%s\n", drizzle_error(__drizzle)); \
    return ret; \
  } \
}

typedef struct
{
  drizzle_st drizzle;
  drizzle_con_st con;
  drizzle_result_st result;
  drizzle_column_st column;
  sqlite3* db;
  bool send_columns;
  drizzle_verbose_t verbose;
  uint64_t rows;
} sqlite_server;

static void server_run(sqlite_server *server);
static int row_cb(void *data, int field_count, char **fields, char **columns);
static drizzle_return_t send_version(sqlite_server *server);
static void usage(char *name);

int main(int argc, char *argv[])
{
  int c;
  uint32_t count= 0;
  const char *host= NULL;
  bool mysql= false;
  in_port_t port= 0;
  drizzle_return_t ret;
  sqlite_server *server= (sqlite_server*)malloc(sizeof(sqlite_server));
  drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));

  server->db= NULL;
  server->verbose= DRIZZLE_VERBOSE_NEVER;

  while((c = getopt(argc, argv, "c:h:mp:v")) != -1)
  {
    switch(c)
    {
    case 'c':
      count= (uint32_t)atoi(optarg);
      break;

    case 'h':
      host= optarg;
      break;

    case 'm':
      mysql= true;
      break;

    case 'p':
      port= (in_port_t)atoi(optarg);
      break;

    case 'v':
      server->verbose++;
      break;

    default:
      usage(argv[0]);
      return 1;
    }
  }

  if (argc != (optind + 1))
  {
    usage(argv[0]);
    return 1;
  }

  sqlite3_open(argv[optind], &(server->db));
  if (server->db == NULL)
  {
    printf("sqlite3_open: could not open sqlite3 db\n");
    return 1;
  }

  if (drizzle_create(&(server->drizzle)) == NULL)
  {
    printf("drizzle_create:NULL\n");
    return 1;
  }

  drizzle_add_options(&(server->drizzle), DRIZZLE_FREE_OBJECTS);
  drizzle_set_verbose(&(server->drizzle), server->verbose);

  if (drizzle_con_create(&(server->drizzle), con_listen) == NULL)
  {
    printf("drizzle_con_create:NULL\n");
    return 1;
  }

  drizzle_con_add_options(con_listen, DRIZZLE_CON_LISTEN);
  drizzle_con_set_tcp(con_listen, host, port);

  if (mysql)
    drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);

  if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
  {
    printf("drizzle_con_listen:%s\n", drizzle_error(&(server->drizzle)));
    return 1;
  }

  while (1)
  {
    (void)drizzle_con_accept(&(server->drizzle), &(server->con), &ret);
    if (ret != DRIZZLE_RETURN_OK)
    {
      printf("drizzle_con_accept:%s\n", drizzle_error(&(server->drizzle)));
      return 1;
    }

    server_run(server);

    drizzle_con_free(&(server->con));

    if (count > 0)
    {
      count--;

      if (count == 0)
        break;
    }
  }

  drizzle_con_free(con_listen);
  drizzle_free(&(server->drizzle));
  sqlite3_close(server->db);
  free(con_listen);
  free(server);

  return 0;
}

static void server_run(sqlite_server *server)
{
  drizzle_return_t ret;
  drizzle_command_t command;
  uint8_t *data= NULL;
  size_t total;
  int sqlite_ret;
  char *sqlite_err;

  /* Handshake packets. */
  drizzle_con_set_protocol_version(&(server->con), 10);
  drizzle_con_set_server_version(&(server->con), "libdrizzle+SQLite");
  drizzle_con_set_thread_id(&(server->con), 1);
  drizzle_con_set_scramble(&(server->con),
                           (const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
  drizzle_con_set_capabilities(&(server->con), DRIZZLE_CAPABILITIES_NONE);
  drizzle_con_set_charset(&(server->con), 8);
  drizzle_con_set_status(&(server->con), DRIZZLE_CON_STATUS_NONE);
  drizzle_con_set_max_packet_size(&(server->con), DRIZZLE_MAX_PACKET_SIZE);

  ret= drizzle_handshake_server_write(&(server->con));
  DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write",
                       &(server->drizzle))

  ret= drizzle_handshake_client_read(&(server->con));
  DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", &(server->drizzle))

  if (drizzle_result_create(&(server->con), &(server->result)) == NULL)
    DRIZZLE_RETURN_ERROR("drizzle_result_create", &(server->drizzle))

  ret= drizzle_result_write(&(server->con), &(server->result), true);
  DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))

  /* Command loop. */
  while (1)
  {
    drizzle_result_free(&(server->result));
    if (data != NULL)
      free(data);

    data= drizzle_con_command_buffer(&(server->con), &command, &total, &ret);
    if (ret == DRIZZLE_RETURN_LOST_CONNECTION ||
        (ret == DRIZZLE_RETURN_OK && command == DRIZZLE_COMMAND_QUIT))
    {
      if (data != NULL)
        free(data);
      return;
    }
    DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", &(server->drizzle))

    if (server->verbose >= DRIZZLE_VERBOSE_INFO)
    {
      printf("Command=%u Data=%s\n", command,
             data == NULL ? "NULL" : (char *)data);
    }

    if (drizzle_result_create(&(server->con), &(server->result)) == NULL)
      DRIZZLE_RETURN_ERROR("drizzle_result_create", &(server->drizzle))

    if (command != DRIZZLE_COMMAND_QUERY ||
        !strcasecmp((char *)data, "SHOW DATABASES"))
    {
      ret= drizzle_result_write(&(server->con), &(server->result), true);
      DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))

      if (command == DRIZZLE_COMMAND_FIELD_LIST)
      {
        drizzle_result_set_eof(&(server->result), true);
        ret= drizzle_result_write(&(server->con), &(server->result), true);
        DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
      }

      continue;
    }

    if (strstr((char *)data, "@@version") != NULL)
    {
      ret= send_version(server);
      if (ret != DRIZZLE_RETURN_OK)
        return;

      continue;
    }

    server->send_columns= true;
    server->rows= 0;

    if (!strcasecmp((char *)data, "SHOW TABLES"))
    {
      sqlite_ret= sqlite3_exec(server->db,
                            "SELECT name FROM sqlite_master WHERE type='table'",
                               row_cb, server, &sqlite_err);
    }
    else
    {
      sqlite_ret= sqlite3_exec(server->db, (char *)data, row_cb, server,
                               &sqlite_err);
    }

    if (sqlite_ret != SQLITE_OK)
    {
      if (sqlite_err == NULL)
        printf("sqlite3_exec failed\n");
      else
      {
        drizzle_result_set_error_code(&(server->result), (uint16_t)sqlite_ret);
        drizzle_result_set_error(&(server->result), sqlite_err);
        ret= drizzle_result_write(&(server->con), &(server->result), true);
        DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))

        printf("sqlite3_exec:%s\n", sqlite_err);
        sqlite3_free(sqlite_err);
      }

      return;
    }

    if (server->rows == 0)
    {
      drizzle_result_set_column_count(&(server->result), 0);
      ret= drizzle_result_write(&(server->con), &(server->result), true);
      DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
    }
    else
    {
      drizzle_result_set_eof(&(server->result), true);
      ret= drizzle_result_write(&(server->con), &(server->result), true);
      DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
    }
  }
}

static int row_cb(void *data, int field_count, char **fields, char **columns)
{
  sqlite_server *server= (sqlite_server *)data;
  drizzle_return_t ret;
  int x;
  size_t *sizes= (size_t*)malloc(sizeof(size_t)*8192);

  if (server->send_columns == true)
  {
    server->send_columns= false;
    drizzle_result_set_column_count(&(server->result), (uint16_t)field_count);

    ret= drizzle_result_write(&(server->con), &(server->result), false);
    DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))

    if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
    {
      DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create",
                               &(server->drizzle))
    }

    drizzle_column_set_catalog(&(server->column), "sqlite");
    drizzle_column_set_db(&(server->column), "sqlite_db");
    drizzle_column_set_table(&(server->column), "sqlite_table");
    drizzle_column_set_orig_table(&(server->column), "sqlite_table");
    drizzle_column_set_charset(&(server->column), 8);
    drizzle_column_set_type(&(server->column), DRIZZLE_COLUMN_TYPE_VARCHAR);

    for (x= 0; x < field_count; x++)
    {
      drizzle_column_set_size(&(server->column),
                              fields[x] == NULL ?
                              0 : (uint32_t)strlen(fields[x]));
      drizzle_column_set_name(&(server->column), columns[x]);
      drizzle_column_set_orig_name(&(server->column), columns[x]);

      ret= drizzle_column_write(&(server->result), &(server->column));
      DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", &(server->drizzle))
    }

    drizzle_column_free(&(server->column));

    drizzle_result_set_eof(&(server->result), true);

    ret= drizzle_result_write(&(server->con), &(server->result), false);
    DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
  }

  for (x= 0; x < field_count; x++)
  {
    if (fields[x] == NULL)
      sizes[x]= 0;
    else
      sizes[x]= strlen(fields[x]);
  }

  /* This is needed for MySQL and old Drizzle protocol. */
  drizzle_result_calc_row_size(&(server->result), (drizzle_field_t *)fields,
                               sizes);

  ret= drizzle_row_write(&(server->result));
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", &(server->drizzle))

  for (x= 0; x < field_count; x++)
  {
    ret= drizzle_field_write(&(server->result), (drizzle_field_t)fields[x],
                             sizes[x], sizes[x]);
    DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", &(server->drizzle))
  }

  server->rows++;

  free(sizes);

  return 0;
}

static drizzle_return_t send_version(sqlite_server *server)
{
  drizzle_return_t ret;
  drizzle_field_t fields[1];
  size_t sizes[1];

  fields[0]= (drizzle_field_t)SQLITE_SERVER_VERSION;
  sizes[0]= strlen(SQLITE_SERVER_VERSION);

  drizzle_result_set_column_count(&(server->result), 1);

  ret= drizzle_result_write(&(server->con), &(server->result), false);
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))

  if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
  {
    DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create",
                             &(server->drizzle))
  }

  drizzle_column_set_catalog(&(server->column), "sqlite");
  drizzle_column_set_db(&(server->column), "sqlite_db");
  drizzle_column_set_table(&(server->column), "sqlite_table");
  drizzle_column_set_orig_table(&(server->column), "sqlite_table");
  drizzle_column_set_charset(&(server->column), 8);
  drizzle_column_set_type(&(server->column), DRIZZLE_COLUMN_TYPE_VARCHAR);
  drizzle_column_set_size(&(server->column), (uint32_t)sizes[0]);
  drizzle_column_set_name(&(server->column), "version");
  drizzle_column_set_orig_name(&(server->column), "version");

  ret= drizzle_column_write(&(server->result), &(server->column));
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", &(server->drizzle))

  drizzle_column_free(&(server->column));

  drizzle_result_set_eof(&(server->result), true);

  ret= drizzle_result_write(&(server->con), &(server->result), false);
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))

  /* This is needed for MySQL and old Drizzle protocol. */
  drizzle_result_calc_row_size(&(server->result), fields, sizes);

  ret= drizzle_row_write(&(server->result));
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", &(server->drizzle))

  ret= drizzle_field_write(&(server->result), fields[0], sizes[0], sizes[0]);
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", &(server->drizzle))

  ret= drizzle_result_write(&(server->con), &(server->result), true);
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))

  return DRIZZLE_RETURN_OK;
}

static void usage(char *name)
{
  printf("\nusage: %s [-c <count>] [-h <host>] [-m] [-p <port>] [-v] "
         "<sqlite3 db file>\n", name);
  printf("\t-c <count> - Number of connections to accept before exiting\n");
  printf("\t-h <host>  - Host to listen on\n");
  printf("\t-m         - Use the MySQL protocol\n");
  printf("\t-p <port>  - Port to listen on\n");
  printf("\t-v         - Increase verbosity level\n");
}

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.4 by Monty Taylor Made BSD files reference root BSD 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	#include <errno.h>
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <string.h>
	15	#include <strings.h>
	16	#include <unistd.h>
	17
	18	#include <libdrizzle/drizzle_server.h>
	19	#include <sqlite3.h>
	20
	21	#define SQLITE_SERVER_VERSION "SQLite Server using libdrizzle 0.1"
	22
	23	#define DRIZZLE_RETURN_CHECK(__ret, __function, __drizzle) \
	24	{ \
	25	if ((__ret) != DRIZZLE_RETURN_OK) \
	26	DRIZZLE_RETURN_ERROR(__function, __drizzle) \
	27	}
	28
	29	#define DRIZZLE_RETURN_ERROR(__function, __drizzle) \
	30	{ \
	31	printf(__function ":%s\n", drizzle_error(__drizzle)); \
	32	return; \
	33	}
	34
	35	#define DRIZZLE_RETURN_CHECK_VAL(__ret, __function, __drizzle) \
	36	{ \
	37	if ((__ret) != DRIZZLE_RETURN_OK) \
	38	{ \
	39	printf(__function ":%s\n", drizzle_error(__drizzle)); \
	40	return ret; \
	41	} \
	42	}
	43
	44	typedef struct
	45	{
	46	drizzle_st drizzle;
	47	drizzle_con_st con;
	48	drizzle_result_st result;
	49	drizzle_column_st column;
	50	sqlite3* db;
	51	bool send_columns;
	52	drizzle_verbose_t verbose;
	53	uint64_t rows;
	54	} sqlite_server;
	55
	56	static void server_run(sqlite_server *server);
	57	static int row_cb(void data, int field_count, char fields, char *columns);
	58	static drizzle_return_t send_version(sqlite_server *server);
	59	static void usage(char *name);
	60
	61	int main(int argc, char *argv[])
	62	{
	63	int c;
	64	uint32_t count= 0;
	65	const char *host= NULL;
	66	bool mysql= false;
	67	in_port_t port= 0;
	68	drizzle_return_t ret;
1929.1.35 by Stewart Smith typo	69	sqlite_server server= (sqlite_server)malloc(sizeof(sqlite_server));
1929.1.33 by Stewart Smith fix large stack usag ein examples/sqlite_server.c:	70	drizzle_con_st con_listen= (drizzle_con_st)malloc(sizeof(drizzle_con_st));
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	71
1929.1.34 by Stewart Smith fix sqlite_server stack usage	72	server->db= NULL;
1929.1.34 by Stewart Smith fix sqlite_server stack usage	73	server->verbose= DRIZZLE_VERBOSE_NEVER;
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	74
	75	while((c = getopt(argc, argv, "c:h:mp:v")) != -1)
	76	{
	77	switch(c)
	78	{
	79	case 'c':
	80	count= (uint32_t)atoi(optarg);
	81	break;
	82
	83	case 'h':
	84	host= optarg;
	85	break;
	86
	87	case 'm':
	88	mysql= true;
	89	break;
	90
	91	case 'p':
	92	port= (in_port_t)atoi(optarg);
	93	break;
	94
	95	case 'v':
1929.1.34 by Stewart Smith fix sqlite_server stack usage	96	server->verbose++;
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	97	break;
	98
	99	default:
	100	usage(argv[0]);
	101	return 1;
	102	}
	103	}
	104
	105	if (argc != (optind + 1))
	106	{
	107	usage(argv[0]);
	108	return 1;
	109	}
	110
1929.1.34 by Stewart Smith fix sqlite_server stack usage	111	sqlite3_open(argv[optind], &(server->db));
1929.1.34 by Stewart Smith fix sqlite_server stack usage	112	if (server->db == NULL)
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	113	{
	114	printf("sqlite3_open: could not open sqlite3 db\n");
	115	return 1;
	116	}
	117
1929.1.34 by Stewart Smith fix sqlite_server stack usage	118	if (drizzle_create(&(server->drizzle)) == NULL)
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	119	{
	120	printf("drizzle_create:NULL\n");
	121	return 1;
	122	}
	123
1929.1.34 by Stewart Smith fix sqlite_server stack usage	124	drizzle_add_options(&(server->drizzle), DRIZZLE_FREE_OBJECTS);
1929.1.34 by Stewart Smith fix sqlite_server stack usage	125	drizzle_set_verbose(&(server->drizzle), server->verbose);
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	126
1929.1.34 by Stewart Smith fix sqlite_server stack usage	127	if (drizzle_con_create(&(server->drizzle), con_listen) == NULL)
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	128	{
	129	printf("drizzle_con_create:NULL\n");
	130	return 1;
	131	}
	132
1929.1.33 by Stewart Smith fix large stack usag ein examples/sqlite_server.c:	133	drizzle_con_add_options(con_listen, DRIZZLE_CON_LISTEN);
	134	drizzle_con_set_tcp(con_listen, host, port);
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	135
	136	if (mysql)
1929.1.33 by Stewart Smith fix large stack usag ein examples/sqlite_server.c:	137	drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	138
1929.1.33 by Stewart Smith fix large stack usag ein examples/sqlite_server.c:	139	if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	140	{
1929.1.34 by Stewart Smith fix sqlite_server stack usage	141	printf("drizzle_con_listen:%s\n", drizzle_error(&(server->drizzle)));
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	142	return 1;
	143	}
	144
	145	while (1)
	146	{
1929.1.34 by Stewart Smith fix sqlite_server stack usage	147	(void)drizzle_con_accept(&(server->drizzle), &(server->con), &ret);
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	148	if (ret != DRIZZLE_RETURN_OK)
	149	{
1929.1.34 by Stewart Smith fix sqlite_server stack usage	150	printf("drizzle_con_accept:%s\n", drizzle_error(&(server->drizzle)));
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	151	return 1;
	152	}
	153
1929.1.34 by Stewart Smith fix sqlite_server stack usage	154	server_run(server);
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	155
1929.1.34 by Stewart Smith fix sqlite_server stack usage	156	drizzle_con_free(&(server->con));
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	157
	158	if (count > 0)
	159	{
	160	count--;
	161
	162	if (count == 0)
	163	break;
	164	}
	165	}
	166
1929.1.33 by Stewart Smith fix large stack usag ein examples/sqlite_server.c:	167	drizzle_con_free(con_listen);
1929.1.34 by Stewart Smith fix sqlite_server stack usage	168	drizzle_free(&(server->drizzle));
1929.1.34 by Stewart Smith fix sqlite_server stack usage	169	sqlite3_close(server->db);
1929.1.33 by Stewart Smith fix large stack usag ein examples/sqlite_server.c:	170	free(con_listen);
1929.1.34 by Stewart Smith fix sqlite_server stack usage	171	free(server);
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	172
	173	return 0;
	174	}
	175
	176	static void server_run(sqlite_server *server)
	177	{
	178	drizzle_return_t ret;
	179	drizzle_command_t command;
	180	uint8_t *data= NULL;
	181	size_t total;
	182	int sqlite_ret;
	183	char *sqlite_err;
	184
	185	/* Handshake packets. */
	186	drizzle_con_set_protocol_version(&(server->con), 10);
	187	drizzle_con_set_server_version(&(server->con), "libdrizzle+SQLite");
	188	drizzle_con_set_thread_id(&(server->con), 1);
	189	drizzle_con_set_scramble(&(server->con),
	190	(const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
	191	drizzle_con_set_capabilities(&(server->con), DRIZZLE_CAPABILITIES_NONE);
	192	drizzle_con_set_charset(&(server->con), 8);
	193	drizzle_con_set_status(&(server->con), DRIZZLE_CON_STATUS_NONE);
	194	drizzle_con_set_max_packet_size(&(server->con), DRIZZLE_MAX_PACKET_SIZE);
	195
	196	ret= drizzle_handshake_server_write(&(server->con));
	197	DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write",
	198	&(server->drizzle))
	199
	200	ret= drizzle_handshake_client_read(&(server->con));
	201	DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", &(server->drizzle))
	202
	203	if (drizzle_result_create(&(server->con), &(server->result)) == NULL)
	204	DRIZZLE_RETURN_ERROR("drizzle_result_create", &(server->drizzle))
	205
	206	ret= drizzle_result_write(&(server->con), &(server->result), true);
	207	DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
	208
	209	/* Command loop. */
	210	while (1)
	211	{
	212	drizzle_result_free(&(server->result));
	213	if (data != NULL)
	214	free(data);
	215
	216	data= drizzle_con_command_buffer(&(server->con), &command, &total, &ret);
	217	if (ret == DRIZZLE_RETURN_LOST_CONNECTION \|\|
	218	(ret == DRIZZLE_RETURN_OK && command == DRIZZLE_COMMAND_QUIT))
	219	{
	220	if (data != NULL)
	221	free(data);
	222	return;
	223	}
	224	DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", &(server->drizzle))
	225
	226	if (server->verbose >= DRIZZLE_VERBOSE_INFO)
	227	{
	228	printf("Command=%u Data=%s\n", command,
	229	data == NULL ? "NULL" : (char *)data);
	230	}
	231
	232	if (drizzle_result_create(&(server->con), &(server->result)) == NULL)
	233	DRIZZLE_RETURN_ERROR("drizzle_result_create", &(server->drizzle))
	234
	235	if (command != DRIZZLE_COMMAND_QUERY \|\|
236	!strcasecmp((char *)data, "SHOW DATABASES"))
237	{
238	ret= drizzle_result_write(&(server->con), &(server->result), true);
239	DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
240
241	if (command == DRIZZLE_COMMAND_FIELD_LIST)
242	{
243	drizzle_result_set_eof(&(server->result), true);
244	ret= drizzle_result_write(&(server->con), &(server->result), true);
245	DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
246	}
247
248	continue;
249	}
250
251	if (strstr((char *)data, "@@version") != NULL)
252	{
253	ret= send_version(server);
254	if (ret != DRIZZLE_RETURN_OK)
255	return;
256
257	continue;
258	}
259
260	server->send_columns= true;
261	server->rows= 0;
262
263	if (!strcasecmp((char *)data, "SHOW TABLES"))
264	{
265	sqlite_ret= sqlite3_exec(server->db,
266	"SELECT name FROM sqlite_master WHERE type='table'",
267	row_cb, server, &sqlite_err);
268	}
269	else
270	{
271	sqlite_ret= sqlite3_exec(server->db, (char *)data, row_cb, server,
272	&sqlite_err);
273	}
274
275	if (sqlite_ret != SQLITE_OK)
276	{
277	if (sqlite_err == NULL)
278	printf("sqlite3_exec failed\n");
279	else
280	{
281	drizzle_result_set_error_code(&(server->result), (uint16_t)sqlite_ret);
282	drizzle_result_set_error(&(server->result), sqlite_err);
283	ret= drizzle_result_write(&(server->con), &(server->result), true);
284	DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
285
286	printf("sqlite3_exec:%s\n", sqlite_err);
287	sqlite3_free(sqlite_err);
288	}
289
290	return;
291	}
292
293	if (server->rows == 0)
294	{
295	drizzle_result_set_column_count(&(server->result), 0);
296	ret= drizzle_result_write(&(server->con), &(server->result), true);
297	DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
298	}
299	else
300	{
301	drizzle_result_set_eof(&(server->result), true);
302	ret= drizzle_result_write(&(server->con), &(server->result), true);
303	DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
304	}
305	}
306	}
307
308	static int row_cb(void data, int field_count, char fields, char *columns)
309	{
310	sqlite_server server= (sqlite_server )data;
311	drizzle_return_t ret;
312	int x;
1929.1.36 by Stewart Smith one last sqlite_server stack fix	313	size_t sizes= (size_t)malloc(sizeof(size_t)*8192);
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	314
	315	if (server->send_columns == true)
	316	{
	317	server->send_columns= false;
	318	drizzle_result_set_column_count(&(server->result), (uint16_t)field_count);
	319
	320	ret= drizzle_result_write(&(server->con), &(server->result), false);
	321	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
	322
	323	if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
	324	{
	325	DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create",
	326	&(server->drizzle))
	327	}
	328
	329	drizzle_column_set_catalog(&(server->column), "sqlite");
	330	drizzle_column_set_db(&(server->column), "sqlite_db");
	331	drizzle_column_set_table(&(server->column), "sqlite_table");
	332	drizzle_column_set_orig_table(&(server->column), "sqlite_table");
	333	drizzle_column_set_charset(&(server->column), 8);
	334	drizzle_column_set_type(&(server->column), DRIZZLE_COLUMN_TYPE_VARCHAR);
	335
	336	for (x= 0; x < field_count; x++)
	337	{
	338	drizzle_column_set_size(&(server->column),
	339	fields[x] == NULL ?
	340	0 : (uint32_t)strlen(fields[x]));
	341	drizzle_column_set_name(&(server->column), columns[x]);
	342	drizzle_column_set_orig_name(&(server->column), columns[x]);
	343
	344	ret= drizzle_column_write(&(server->result), &(server->column));
	345	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", &(server->drizzle))
	346	}
	347
	348	drizzle_column_free(&(server->column));
	349
	350	drizzle_result_set_eof(&(server->result), true);
	351
	352	ret= drizzle_result_write(&(server->con), &(server->result), false);
	353	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
	354	}
	355
	356	for (x= 0; x < field_count; x++)
	357	{
	358	if (fields[x] == NULL)
	359	sizes[x]= 0;
	360	else
	361	sizes[x]= strlen(fields[x]);
	362	}
	363
	364	/* This is needed for MySQL and old Drizzle protocol. */
	365	drizzle_result_calc_row_size(&(server->result), (drizzle_field_t *)fields,
	366	sizes);
	367
	368	ret= drizzle_row_write(&(server->result));
	369	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", &(server->drizzle))
	370
	371	for (x= 0; x < field_count; x++)
	372	{
	373	ret= drizzle_field_write(&(server->result), (drizzle_field_t)fields[x],
	374	sizes[x], sizes[x]);
	375	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", &(server->drizzle))
	376	}
	377
378	server->rows++;
379
1929.1.36 by Stewart Smith one last sqlite_server stack fix	380	free(sizes);
1929.1.36 by Stewart Smith one last sqlite_server stack fix	381
1712.1.1 by Monty Taylor Merged libdrizzle directly into tree.	382	return 0;
	383	}
	384
	385	static drizzle_return_t send_version(sqlite_server *server)
	386	{
	387	drizzle_return_t ret;
	388	drizzle_field_t fields[1];
	389	size_t sizes[1];
	390
	391	fields[0]= (drizzle_field_t)SQLITE_SERVER_VERSION;
	392	sizes[0]= strlen(SQLITE_SERVER_VERSION);
	393
	394	drizzle_result_set_column_count(&(server->result), 1);
	395
	396	ret= drizzle_result_write(&(server->con), &(server->result), false);
	397	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
	398
	399	if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
	400	{
	401	DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create",
	402	&(server->drizzle))
	403	}
	404
	405	drizzle_column_set_catalog(&(server->column), "sqlite");
	406	drizzle_column_set_db(&(server->column), "sqlite_db");
	407	drizzle_column_set_table(&(server->column), "sqlite_table");
	408	drizzle_column_set_orig_table(&(server->column), "sqlite_table");
	409	drizzle_column_set_charset(&(server->column), 8);
	410	drizzle_column_set_type(&(server->column), DRIZZLE_COLUMN_TYPE_VARCHAR);
	411	drizzle_column_set_size(&(server->column), (uint32_t)sizes[0]);
	412	drizzle_column_set_name(&(server->column), "version");
	413	drizzle_column_set_orig_name(&(server->column), "version");
	414
	415	ret= drizzle_column_write(&(server->result), &(server->column));
	416	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", &(server->drizzle))
	417
	418	drizzle_column_free(&(server->column));
	419
	420	drizzle_result_set_eof(&(server->result), true);
	421
	422	ret= drizzle_result_write(&(server->con), &(server->result), false);
	423	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
	424
	425	/* This is needed for MySQL and old Drizzle protocol. */
	426	drizzle_result_calc_row_size(&(server->result), fields, sizes);
	427
	428	ret= drizzle_row_write(&(server->result));
	429	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", &(server->drizzle))
	430
	431	ret= drizzle_field_write(&(server->result), fields[0], sizes[0], sizes[0]);
	432	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", &(server->drizzle))
	433
	434	ret= drizzle_result_write(&(server->con), &(server->result), true);
	435	DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
	436
	437	return DRIZZLE_RETURN_OK;
	438	}
	439
	440	static void usage(char *name)
	441	{
	442	printf("\nusage: %s [-c <count>] [-h <host>] [-m] [-p <port>] [-v] "
	443	"<sqlite3 db file>\n", name);
	444	printf("\t-c <count> - Number of connections to accept before exiting\n");
	445	printf("\t-h <host> - Host to listen on\n");
446	printf("\t-m - Use the MySQL protocol\n");
447	printf("\t-p <port> - Port to listen on\n");
448	printf("\t-v - Increase verbosity level\n");
449	}