~drizzle-trunk/drizzle/development

/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
  This file is included by both libdrizzle.c (the DRIZZLE client C API)
  and the drizzled server to connect to another DRIZZLE server.

  The differences for the two cases are:

  - Things that only works for the client:
  - Trying to automaticly determinate user name if not supplied to
    drizzle_connect()
  - Support for reading local file with LOAD DATA LOCAL
  - SHARED memory handling
  - Prepared statements
 
  - Things that only works for the server
  - Alarm handling on connect
 
  In all other cases, the code should be idential for the client and
  server.
*/

#include <stdarg.h>

#include <libdrizzle/libdrizzle.h>
#include <libdrizzle/net_serv.h>
#include "libdrizzle_priv.h"

#include <sys/poll.h>
#include <sys/ioctl.h>

#include <netdb.h>

/* Remove client convenience wrappers */
#undef max_allowed_packet
#undef net_buffer_length

#include <libdrizzle/errmsg.h>
#include <vio/violite.h>

#include <sys/stat.h>
#include <signal.h>
#include <time.h>
#ifdef   HAVE_PWD_H
#include <pwd.h>
#endif

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#ifdef HAVE_SELECT_H
#  include <select.h>
#endif
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif

#include <sys/un.h>

#include <errno.h>
#define SOCKET_ERROR -1


#include <drizzled/version.h>
#include <libdrizzle/sql_common.h>
#include <libdrizzle/gettext.h>
#include "local_infile.h"








#if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
struct passwd *getpwuid(uid_t);
char* getlogin(void);
#endif



/*****************************************************************************
  Read a packet from server. Give error message if socket was down
  or packet is an error message
*****************************************************************************/

uint32_t cli_safe_read(DRIZZLE *drizzle)
{
  NET *net= &drizzle->net;
  uint32_t len=0;

  if (net->vio != 0)
    len=my_net_read(net);

  if (len == packet_error || len == 0)
  {
#ifdef DRIZZLE_SERVER
    if (net->vio && vio_was_interrupted(net->vio))
      return (packet_error);
#endif /*DRIZZLE_SERVER*/
    drizzle_disconnect(drizzle);
    drizzle_set_error(drizzle, net->last_errno == CR_NET_PACKET_TOO_LARGE ?
                      CR_NET_PACKET_TOO_LARGE : CR_SERVER_LOST,
                      sqlstate_get_unknown());
    return (packet_error);
  }
  if (net->read_pos[0] == 255)
  {
    if (len > 3)
    {
      char *pos=(char*) net->read_pos+1;
      net->last_errno=uint2korr(pos);
      pos+=2;
      len-=2;
      if (pos[0] == '#')
      {
        strncpy(net->sqlstate, pos+1, SQLSTATE_LENGTH);
        pos+= SQLSTATE_LENGTH+1;
      }
      else
      {
        /*
          The SQL state hasn't been received -- it should be reset to HY000
          (unknown error sql state).
        */

        strcpy(net->sqlstate, sqlstate_get_unknown());
      }

      strncpy(net->last_error,(char*) pos, min((uint32_t) len,
              (uint32_t) sizeof(net->last_error)-1));
    }
    else
      drizzle_set_error(drizzle, CR_UNKNOWN_ERROR, sqlstate_get_unknown());
    /*
      Cover a protocol design error: error packet does not
      contain the server status. Therefore, the client has no way
      to find out whether there are more result sets of
      a multiple-result-set statement pending. Luckily, in 5.0 an
      error always aborts execution of a statement, wherever it is
      a multi-statement or a stored procedure, so it should be
      safe to unconditionally turn off the flag here.
    */
    drizzle->server_status&= ~SERVER_MORE_RESULTS_EXISTS;

    return(packet_error);
  }
  return len;
}

bool
cli_advanced_command(DRIZZLE *drizzle, enum enum_server_command command,
         const unsigned char *header, uint32_t header_length,
         const unsigned char *arg, uint32_t arg_length, bool skip_check)
{
  NET *net= &drizzle->net;
  bool result= 1;
  bool stmt_skip= false;

  if (drizzle->net.vio == 0)
  {            /* Do reconnect if possible */
    if (drizzle_reconnect(drizzle) || stmt_skip)
      return(1);
  }
  if (drizzle->status != DRIZZLE_STATUS_READY ||
      drizzle->server_status & SERVER_MORE_RESULTS_EXISTS)
  {
    drizzle_set_error(drizzle, CR_COMMANDS_OUT_OF_SYNC,
                      sqlstate_get_unknown());
    return(1);
  }

  net_clear_error(net);
  drizzle->info=0;
  drizzle->affected_rows= ~(uint64_t) 0;
  /*
    We don't want to clear the protocol buffer on COM_QUIT, because if
    the previous command was a shutdown command, we may have the
    response for the COM_QUIT already in the communication buffer
  */
  net_clear(&drizzle->net, (command != COM_QUIT));

  if (net_write_command(net,(unsigned char) command, header, header_length,
      arg, arg_length))
  {
    if (net->last_errno == CR_NET_PACKET_TOO_LARGE)
    {
      drizzle_set_error(drizzle, CR_NET_PACKET_TOO_LARGE, sqlstate_get_unknown());
      goto end;
    }
    drizzle_disconnect(drizzle);
    if (drizzle_reconnect(drizzle) || stmt_skip)
      goto end;
    if (net_write_command(net,(unsigned char) command, header, header_length,
        arg, arg_length))
    {
      drizzle_set_error(drizzle, CR_SERVER_GONE_ERROR, sqlstate_get_unknown());
      goto end;
    }
  }
  result=0;
  if (!skip_check)
    result= ((drizzle->packet_length=cli_safe_read(drizzle)) == packet_error ?
       1 : 0);
end:
  return(result);
}

void free_old_query(DRIZZLE *drizzle)
{
  if (drizzle->fields)
  {
    /* TODO - we need to de-alloc field storage */
    free(drizzle->fields->catalog);
    free(drizzle->fields->db);
    free(drizzle->fields->table);
    free(drizzle->fields->org_table);
    free(drizzle->fields->name);
    free(drizzle->fields->org_name);
    free(drizzle->fields->def);
    free(drizzle->fields);

  }
  /* init_alloc_root(&drizzle->field_alloc,8192,0); */ /* Assume rowlength < 8192 */
  drizzle->fields= 0;
  drizzle->field_count= 0;      /* For API */
  drizzle->warning_count= 0;
  drizzle->info= 0;
  return;
}





void
drizzle_free_result(DRIZZLE_RES *result)
{
  if (result)
  {
    DRIZZLE *drizzle= result->handle;
    if (drizzle)
    {
      if (drizzle->unbuffered_fetch_owner == &result->unbuffered_fetch_cancelled)
        drizzle->unbuffered_fetch_owner= 0;
      if (drizzle->status == DRIZZLE_STATUS_USE_RESULT)
      {
        (*drizzle->methods->flush_use_result)(drizzle);
        drizzle->status=DRIZZLE_STATUS_READY;
        if (drizzle->unbuffered_fetch_owner)
          *drizzle->unbuffered_fetch_owner= true;
      }
    }
    free_rows(result->data);
    /* TODO: free result->fields */
    if (result->row)
      free((unsigned char*) result->row);
    free((unsigned char*) result);
  }
}




/* Read all rows (fields or data) from server */

DRIZZLE_DATA *cli_read_rows(DRIZZLE *drizzle, DRIZZLE_FIELD *DRIZZLE_FIELDs, uint32_t fields)
{
  uint32_t  field;
  uint32_t pkt_len;
  uint32_t len;
  unsigned char *cp;
  char  *to, *end_to;
  DRIZZLE_DATA *result;
  DRIZZLE_ROWS **prev_ptr,*cur;
  NET *net = &drizzle->net;

  if ((pkt_len= cli_safe_read(drizzle)) == packet_error)
    return(0);
  if (!(result=(DRIZZLE_DATA*) malloc(sizeof(DRIZZLE_DATA))))
  {
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY,
                      sqlstate_get_unknown());
    return(0);
  }
  memset(result, 0, sizeof(DRIZZLE_DATA));
  prev_ptr= &result->data;
  result->rows=0;
  result->fields=fields;

  /*
    The last EOF packet is either a 254 (0xFE) character followed by 1-7 status bytes.

    This doesn't conflict with normal usage of 254 which stands for a
    string where the length of the string is 8 bytes. (see net_field_length())
  */

  while (*(cp=net->read_pos) != DRIZZLE_PROTOCOL_NO_MORE_DATA || pkt_len >= 8)
  {
    result->rows++;
    if (!(cur= (DRIZZLE_ROWS*) malloc(sizeof(DRIZZLE_ROWS))) ||
        !(cur->data= ((DRIZZLE_ROW) malloc((fields+1)*sizeof(char *)+pkt_len))))
    {
      free_rows(result);
      drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, sqlstate_get_unknown());
      return(0);
    }
    *prev_ptr=cur;
    prev_ptr= &cur->next;
    to= (char*) (cur->data+fields+1);
    end_to=to+pkt_len-1;
    for (field=0 ; field < fields ; field++)
    {
      if ((len= net_field_length(&cp)) == NULL_LENGTH)
      {            /* null field */
        cur->data[field] = 0;
      }
      else
      {
        cur->data[field] = to;
        if (len > (uint32_t) (end_to - to))
        {
          free_rows(result);
          drizzle_set_error(drizzle, CR_MALFORMED_PACKET,
                            sqlstate_get_unknown());
          return(0);
        }
        memcpy(to, cp, len);
        to[len]=0;
        to+=len+1;
        cp+=len;
        if (DRIZZLE_FIELDs)
        {
          if (DRIZZLE_FIELDs[field].max_length < len)
            DRIZZLE_FIELDs[field].max_length=len;
        }
      }
    }
    cur->data[field]=to;      /* End of last field */
    if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
    {
      free_rows(result);
      return(0);
    }
  }
  *prev_ptr=0;          /* last pointer is null */
  if (pkt_len > 1)        /* DRIZZLE 4.1 protocol */
  {
    drizzle->warning_count= uint2korr(cp+1);
    drizzle->server_status= uint2korr(cp+3);
  }
  return(result);
}

/*
  Read one row. Uses packet buffer as storage for fields.
  When next packet is read, the previous field values are destroyed
*/


static int32_t
read_one_row(DRIZZLE *drizzle, uint32_t fields, DRIZZLE_ROW row, uint32_t *lengths)
{
  uint32_t field;
  uint32_t pkt_len,len;
  unsigned char *pos, *prev_pos, *end_pos;
  NET *net= &drizzle->net;

  if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
    return -1;
  if (pkt_len <= 8 && net->read_pos[0] == DRIZZLE_PROTOCOL_NO_MORE_DATA)
  {
    if (pkt_len > 1)        /* DRIZZLE 4.1 protocol */
    {
      drizzle->warning_count= uint2korr(net->read_pos+1);
      drizzle->server_status= uint2korr(net->read_pos+3);
    }
    return 1;        /* End of data */
  }
  prev_pos= 0;        /* allowed to write at packet[-1] */
  pos=net->read_pos;
  end_pos=pos+pkt_len;
  for (field=0 ; field < fields ; field++)
  {
    if ((len= net_field_length(&pos)) == NULL_LENGTH)
    {            /* null field */
      row[field] = 0;
      *lengths++=0;
    }
    else
    {
      if (len > (uint32_t) (end_pos - pos))
      {
        drizzle_set_error(drizzle, CR_UNKNOWN_ERROR,
                          sqlstate_get_unknown());
        return -1;
      }
      row[field] = (char*) pos;
      pos+=len;
      *lengths++=len;
    }
    if (prev_pos)
      *prev_pos=0;        /* Terminate prev field */
    prev_pos=pos;
  }
  row[field]=(char*) prev_pos+1;    /* End of last field */
  *prev_pos=0;          /* Terminate last field */
  return 0;
}


/**************************************************************************
  Return next row of the query results
**************************************************************************/

DRIZZLE_ROW
drizzle_fetch_row(DRIZZLE_RES *res)
{
  if (!res->data)
  {            /* Unbufferred fetch */
    if (!res->eof)
    {
      DRIZZLE *drizzle= res->handle;
      if (drizzle->status != DRIZZLE_STATUS_USE_RESULT)
      {
        drizzle_set_error(drizzle,
                          res->unbuffered_fetch_cancelled ?
                          CR_FETCH_CANCELED : CR_COMMANDS_OUT_OF_SYNC,
                          sqlstate_get_unknown());
      }
      else if (!(read_one_row(drizzle, res->field_count, res->row, res->lengths)))
      {
  res->row_count++;
  return(res->current_row=res->row);
      }
      res->eof=1;
      drizzle->status=DRIZZLE_STATUS_READY;
      /*
        Reset only if owner points to us: there is a chance that somebody
        started new query after drizzle_stmt_close():
      */
      if (drizzle->unbuffered_fetch_owner == &res->unbuffered_fetch_cancelled)
        drizzle->unbuffered_fetch_owner= 0;
      /* Don't clear handle in drizzle_free_result */
      res->handle=0;
    }
    return((DRIZZLE_ROW) NULL);
  }
  {
    DRIZZLE_ROW tmp;
    if (!res->data_cursor)
    {
      return(res->current_row=(DRIZZLE_ROW) NULL);
    }
    tmp = res->data_cursor->data;
    res->data_cursor = res->data_cursor->next;
    return(res->current_row=tmp);
  }
}


/**************************************************************************
  Get column lengths of the current row
  If one uses drizzle_use_result, res->lengths contains the length information,
  else the lengths are calculated from the offset between pointers.
**************************************************************************/

uint32_t *
drizzle_fetch_lengths(DRIZZLE_RES *res)
{
  DRIZZLE_ROW column;

  if (!(column=res->current_row))
    return 0;          /* Something is wrong */
  if (res->data)
    (*res->methods->fetch_lengths)(res->lengths, column, res->field_count);
  return res->lengths;
}


int
drizzle_options(DRIZZLE *drizzle,enum drizzle_option option, const void *arg)
{
  switch (option) {
  case DRIZZLE_OPT_CONNECT_TIMEOUT:
    drizzle->options.connect_timeout= *(uint32_t*) arg;
    break;
  case DRIZZLE_OPT_READ_TIMEOUT:
    drizzle->options.read_timeout= *(uint32_t*) arg;
    break;
  case DRIZZLE_OPT_WRITE_TIMEOUT:
    drizzle->options.write_timeout= *(uint32_t*) arg;
    break;
  case DRIZZLE_OPT_COMPRESS:
    drizzle->options.compress= 1;      /* Remember for connect */
    drizzle->options.client_flag|= CLIENT_COMPRESS;
    break;
  case DRIZZLE_OPT_LOCAL_INFILE:      /* Allow LOAD DATA LOCAL ?*/
    if (!arg || (*(uint32_t*) arg) ? 1 : 0)
      drizzle->options.client_flag|= CLIENT_LOCAL_FILES;
    else
      drizzle->options.client_flag&= ~CLIENT_LOCAL_FILES;
    break;
  case DRIZZLE_READ_DEFAULT_FILE:
    if (drizzle->options.my_cnf_file != NULL)
      free(drizzle->options.my_cnf_file);
    drizzle->options.my_cnf_file=strdup(arg);
    break;
  case DRIZZLE_READ_DEFAULT_GROUP:
    if (drizzle->options.my_cnf_group != NULL)
      free(drizzle->options.my_cnf_group);
    drizzle->options.my_cnf_group=strdup(arg);
    break;
  case DRIZZLE_OPT_PROTOCOL:
    break;
  case DRIZZLE_OPT_USE_REMOTE_CONNECTION:
  case DRIZZLE_OPT_GUESS_CONNECTION:
    drizzle->options.methods_to_use= option;
    break;
  case DRIZZLE_SET_CLIENT_IP:
    drizzle->options.client_ip= strdup(arg);
    break;
  case DRIZZLE_SECURE_AUTH:
    drizzle->options.secure_auth= *(const bool *) arg;
    break;
  case DRIZZLE_REPORT_DATA_TRUNCATION:
    drizzle->options.report_data_truncation= (*(const bool *) arg) ? 1 : 0;
    break;
  case DRIZZLE_OPT_RECONNECT:
    drizzle->reconnect= *(const bool *) arg;
    break;
  case DRIZZLE_OPT_SSL_VERIFY_SERVER_CERT:
    if (*(const bool*) arg)
      drizzle->options.client_flag|= CLIENT_SSL_VERIFY_SERVER_CERT;
    else
      drizzle->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
    break;
  default:
    return(1);
  }
  return(0);
}


/****************************************************************************
  Functions to get information from the DRIZZLE structure
  These are functions to make shared libraries more usable.
****************************************************************************/

/* DRIZZLE_RES */
uint64_t drizzle_num_rows(const DRIZZLE_RES *res)
{
  return res->row_count;
}

unsigned int drizzle_num_fields(const DRIZZLE_RES *res)
{
  return res->field_count;
}


/*
  Get version number for server in a form easy to test on

  SYNOPSIS
    drizzle_get_server_version()
    drizzle Connection

  EXAMPLE
    4.1.0-alfa ->  40100
 
  NOTES
    We will ensure that a newer server always has a bigger number.

  RETURN
   Signed number > 323000
*/

uint32_t
drizzle_get_server_version(const DRIZZLE *drizzle)
{
  uint32_t major, minor, version;
  char *pos= drizzle->server_version, *end_pos;
  major=   (uint32_t) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
  minor=   (uint32_t) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
  version= (uint32_t) strtoul(pos, &end_pos, 10);
  return (uint32_t) major*10000L+(uint32_t) (minor*100+version);
}