← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/client.c

  • Committer: Brian Aker
  • Date: 2008-08-10 16:57:26 UTC
  • Revision ID: brian@tangent.org-20080810165726-mc1660l11a5vkv69
libdrizzle has ulong removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/client.c
288
288
uint32_t cli_safe_read(DRIZZLE *drizzle)
289
289
{
290
290
  NET *net= &drizzle->net;
291
 
  ulong len=0;
 
291
  uint32_t len=0;
292
292
  init_sigpipe_variables
293
293
 
294
294
  /* Don't give sigpipe errors if the client doesn't want them */
444
444
  /* Clear the current execution status */
445
445
  for (;;)
446
446
  {
447
 
    ulong pkt_len;
 
447
    uint32_t pkt_len;
448
448
    if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
449
449
      break;
450
450
    if (pkt_len <= 8 && drizzle->net.read_pos[0] == DRIZZLE_PROTOCOL_NO_MORE_DATA)
720
720
      continue;
721
721
    }
722
722
    if (start)          /* Found end of prev string */
723
 
      *prev_length= (ulong) (*column-start-1);
 
723
      *prev_length= (uint32_t) (*column-start-1);
724
724
    start= *column;
725
725
    prev_length= to;
726
726
  }
793
793
 
794
794
/* Read all rows (fields or data) from server */
795
795
 
796
 
DRIZZLE_DATA *cli_read_rows(DRIZZLE *drizzle,DRIZZLE_FIELD *DRIZZLE_FIELDs,
797
 
        unsigned int fields)
 
796
DRIZZLE_DATA *cli_read_rows(DRIZZLE *drizzle, DRIZZLE_FIELD *DRIZZLE_FIELDs, uint32_t fields)
798
797
{
799
 
  uint  field;
800
 
  ulong pkt_len;
801
 
  ulong len;
802
 
  uchar *cp;
 
798
  uint32_t  field;
 
799
  uint32_t pkt_len;
 
800
  uint32_t len;
 
801
  unsigned char *cp;
803
802
  char  *to, *end_to;
804
803
  DRIZZLE_DATA *result;
805
804
  DRIZZLE_ROWS **prev_ptr,*cur;
845
844
    end_to=to+pkt_len-1;
846
845
    for (field=0 ; field < fields ; field++)
847
846
    {
848
 
      if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
 
847
      if ((len= net_field_length(&cp)) == NULL_LENGTH)
849
848
      {            /* null field */
850
 
  cur->data[field] = 0;
 
849
        cur->data[field] = 0;
851
850
      }
852
851
      else
853
852
      {
854
 
  cur->data[field] = to;
855
 
        if (len > (ulong) (end_to - to))
 
853
        cur->data[field] = to;
 
854
        if (len > (uint32_t) (end_to - to))
856
855
        {
857
856
          free_rows(result);
858
857
          set_drizzle_error(drizzle, CR_MALFORMED_PACKET, unknown_sqlstate);
859
858
          return(0);
860
859
        }
861
 
  memcpy(to, cp, len);
862
 
  to[len]=0;
863
 
  to+=len+1;
864
 
  cp+=len;
865
 
  if (DRIZZLE_FIELDs)
866
 
  {
867
 
    if (DRIZZLE_FIELDs[field].max_length < len)
868
 
      DRIZZLE_FIELDs[field].max_length=len;
869
 
  }
 
860
        memcpy(to, cp, len);
 
861
        to[len]=0;
 
862
        to+=len+1;
 
863
        cp+=len;
 
864
        if (DRIZZLE_FIELDs)
 
865
        {
 
866
          if (DRIZZLE_FIELDs[field].max_length < len)
 
867
            DRIZZLE_FIELDs[field].max_length=len;
 
868
        }
870
869
      }
871
870
    }
872
871
    cur->data[field]=to;      /* End of last field */
895
894
read_one_row(DRIZZLE *drizzle, uint32_t fields, DRIZZLE_ROW row, uint32_t *lengths)
896
895
{
897
896
  uint field;
898
 
  ulong pkt_len,len;
 
897
  uint32_t pkt_len,len;
899
898
  uchar *pos, *prev_pos, *end_pos;
900
899
  NET *net= &drizzle->net;
901
900
 
915
914
  end_pos=pos+pkt_len;
916
915
  for (field=0 ; field < fields ; field++)
917
916
  {
918
 
    if ((len=(ulong) net_field_length(&pos)) == NULL_LENGTH)
 
917
    if ((len= net_field_length(&pos)) == NULL_LENGTH)
919
918
    {            /* null field */
920
919
      row[field] = 0;
921
920
      *lengths++=0;
922
921
    }
923
922
    else
924
923
    {
925
 
      if (len > (ulong) (end_pos - pos))
 
924
      if (len > (uint32_t) (end_pos - pos))
926
925
      {
927
926
        set_drizzle_error(drizzle, CR_UNKNOWN_ERROR, unknown_sqlstate);
928
927
        return -1;
1534
1533
    for (; ptr < end_command; ptr++)
1535
1534
    {
1536
1535
      DRIZZLE_RES *res;
1537
 
      if (drizzle_real_query(drizzle,*ptr, (ulong) strlen(*ptr)))
 
1536
      if (drizzle_real_query(drizzle,*ptr, (uint32_t) strlen(*ptr)))
1538
1537
  goto error;
1539
1538
      if (drizzle->fields)
1540
1539
      {
1555
1554
    /* Free alloced memory */
1556
1555
    end_server(drizzle);
1557
1556
    drizzle_close_free(drizzle);
1558
 
    if (!(((ulong) client_flag) & CLIENT_REMEMBER_OPTIONS))
 
1557
    if (!(((uint32_t) client_flag) & CLIENT_REMEMBER_OPTIONS))
1559
1558
      drizzle_close_free_options(drizzle);
1560
1559
  }
1561
1560
  return(0);
1622
1621
  int error;
1623
1622
 
1624
1623
  if ((error=simple_command(drizzle,COM_INIT_DB, (const uchar*) db,
1625
 
                            (ulong) strlen(db),0)))
 
1624
                            (uint32_t) strlen(db),0)))
1626
1625
    return(error);
1627
1626
  my_free(drizzle->db,MYF(MY_ALLOW_ZERO_PTR));
1628
1627
  drizzle->db=my_strdup(db,MYF(MY_WME));
1701
1700
static bool cli_read_query_result(DRIZZLE *drizzle)
1702
1701
{
1703
1702
  uchar *pos;
1704
 
  ulong field_count;
 
1703
  uint32_t field_count;
1705
1704
  DRIZZLE_DATA *fields;
1706
 
  ulong length;
 
1705
  uint32_t length;
1707
1706
 
1708
1707
  if ((length = cli_safe_read(drizzle)) == packet_error)
1709
1708
    return(1);
1795
1794
  }
1796
1795
  drizzle->status=DRIZZLE_STATUS_READY;    /* server is ready */
1797
1796
  if (!(result=(DRIZZLE_RES*) my_malloc((uint) (sizeof(DRIZZLE_RES)+
1798
 
                sizeof(ulong) *
 
1797
                sizeof(uint32_t) *
1799
1798
                drizzle->field_count),
1800
1799
              MYF(MY_WME | MY_ZEROFILL))))
1801
1800
  {
1847
1846
    return(0);
1848
1847
  }
1849
1848
  if (!(result=(DRIZZLE_RES*) my_malloc(sizeof(*result)+
1850
 
              sizeof(ulong)*drizzle->field_count,
 
1849
              sizeof(uint32_t)*drizzle->field_count,
1851
1850
              MYF(MY_WME | MY_ZEROFILL))))
1852
1851
    return(0);
1853
1852
  result->lengths=(uint32_t*) (result+1);
2068
2067
  major=   (uint) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
2069
2068
  minor=   (uint) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
2070
2069
  version= (uint) strtoul(pos, &end_pos, 10);
2071
 
  return (ulong) major*10000L+(ulong) (minor*100+version);
 
2070
  return (uint32_t) major*10000L+(uint32_t) (minor*100+version);
2072
2071
}
2073
2072
 
2074
2073