← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/conn.c

Refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/conn.c
86
86
  if (con->fd == -1)
87
87
    return;
88
88
 
89
 
  (void)close(con->fd);
 
89
  (void)closesocket(con->fd);
90
90
  con->fd= -1;
91
91
 
92
92
  con->options&= (drizzle_con_options_t)~DRIZZLE_CON_READY;
195
195
 
196
196
  /* If asking for the experimental Drizzle protocol, clean the MySQL flag. */
197
197
  if (con->options & DRIZZLE_CON_EXPERIMENTAL)
 
198
  {
198
199
    con->options&= (drizzle_con_options_t)~DRIZZLE_CON_MYSQL;
 
200
  }
199
201
}
200
202
 
201
203
void drizzle_con_remove_options(drizzle_con_st *con,
451
453
  return drizzle_con_shutdown(con, result, ret_ptr);
452
454
}
453
455
 
 
456
drizzle_result_st *drizzle_kill(drizzle_con_st *con,
 
457
                                drizzle_result_st *result,
 
458
                                uint32_t query_id,
 
459
                                drizzle_return_t *ret_ptr)
 
460
{
 
461
  uint32_t sent= htonl(query_id);
 
462
  return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_PROCESS_KILL,
 
463
                                   &sent, sizeof(uint32_t), sizeof(uint32_t), ret_ptr);
 
464
}
 
465
 
454
466
drizzle_result_st *drizzle_con_ping(drizzle_con_st *con,
455
467
                                    drizzle_result_st *result,
456
468
                                    drizzle_return_t *ret_ptr)
473
485
                                             size_t total,
474
486
                                             drizzle_return_t *ret_ptr)
475
487
{
 
488
  drizzle_result_st *old_result;
 
489
 
476
490
  if (!(con->options & DRIZZLE_CON_READY))
477
491
  {
478
492
    if (con->options & DRIZZLE_CON_RAW_PACKET)
494
508
      con->result= NULL;
495
509
    else
496
510
    {
 
511
      for (old_result= con->result_list; old_result != NULL; old_result= old_result->next)
 
512
      {
 
513
        if (result == old_result)
 
514
        {
 
515
          drizzle_set_error(con->drizzle, "drizzle_command_write", "result struct already in use");
 
516
          *ret_ptr= DRIZZLE_RETURN_INTERNAL_ERROR;
 
517
          return result;
 
518
        }
 
519
      }
 
520
 
497
521
      con->result= drizzle_result_create(con, result);
498
522
      if (con->result == NULL)
499
523
      {
666
690
  size_t offset= 0;
667
691
  size_t size= 0;
668
692
 
669
 
  command_data= drizzle_con_command_read(con, command, &offset, &size, total,
670
 
                                         ret_ptr);
 
693
  command_data= drizzle_con_command_read(con, command, &offset, &size, total, ret_ptr);
671
694
  if (*ret_ptr != DRIZZLE_RETURN_OK)
672
695
    return NULL;
673
696
 
769
792
    memset(&ai, 0, sizeof(struct addrinfo));
770
793
    ai.ai_socktype= SOCK_STREAM;
771
794
    ai.ai_protocol= IPPROTO_TCP;
 
795
    ai.ai_flags = AI_PASSIVE;
 
796
    ai.ai_family = AF_UNSPEC;
772
797
 
773
798
    if (con->options & DRIZZLE_CON_LISTEN)
774
799
    {
775
 
      ai.ai_flags = AI_PASSIVE;
776
 
      ai.ai_family = AF_UNSPEC;
777
800
      host= tcp->host;
778
801
    }
779
802
    else
950
973
    con->buffer_ptr= con->buffer;
951
974
  }
952
975
 
 
976
  if ((con->revents & POLLIN) == 0 &&
 
977
      (con->drizzle->options & DRIZZLE_NON_BLOCKING))
 
978
  {
 
979
    /* non-blocking mode: return IO_WAIT instead of attempting to read. This
 
980
     * avoids reading immediately after writing a command, which typically
 
981
     * returns EAGAIN. This improves performance. */
 
982
    ret= drizzle_con_set_events(con, POLLIN);
 
983
    if (ret != DRIZZLE_RETURN_OK)
 
984
      return ret;
 
985
    return DRIZZLE_RETURN_IO_WAIT;
 
986
  }
 
987
 
953
988
  while (1)
954
989
  {
 
990
    size_t available_buffer= (size_t)DRIZZLE_MAX_BUFFER_SIZE -
 
991
        ((size_t)(con->buffer_ptr - con->buffer) + con->buffer_size);
955
992
    read_size = recv(con->fd, (char *)con->buffer_ptr + con->buffer_size,
956
 
                     (size_t)DRIZZLE_MAX_BUFFER_SIZE -
957
 
                     ((size_t)(con->buffer_ptr - con->buffer) +
958
 
                      con->buffer_size),0); 
 
993
                     available_buffer, 0);
959
994
#ifdef _WIN32
960
995
    /*Get windows error codes and map it to Posix*/
961
996
    errno = WSAGetLastError();
981
1016
    {
982
1017
      if (errno == EAGAIN)
983
1018
      {
 
1019
        /* clear the read ready flag */
 
1020
        con->revents&= ~POLLIN;
984
1021
        ret= drizzle_con_set_events(con, POLLIN);
985
1022
        if (ret != DRIZZLE_RETURN_OK)
986
 
          return 0;
 
1023
          return ret;
987
1024
 
988
1025
        if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
989
1026
          return DRIZZLE_RETURN_IO_WAIT;
1016
1053
      return DRIZZLE_RETURN_ERRNO;
1017
1054
    }
1018
1055
 
 
1056
    /* clear the "read ready" flag if we read all available data. */
 
1057
    if ((size_t) read_size < available_buffer) con->revents&= ~POLLIN;
1019
1058
    con->buffer_size+= (size_t)read_size;
1020
1059
    break;
1021
1060
  }
1022
1061
 
1023
 
  drizzle_state_pop(con);;
 
1062
  drizzle_state_pop(con);
1024
1063
  return DRIZZLE_RETURN_OK;
1025
1064
}
1026
1065
 
1303
1342
  }
1304
1343
 
1305
1344
#if defined (_WIN32)
1306
 
  unsigned long asyncmode = 1;
1307
 
  ioctlsocket(con->fd, FIONBIO, &asyncmode);
 
1345
  {
 
1346
    unsigned long asyncmode;
 
1347
    asyncmode= 1;
 
1348
    ioctlsocket(con->fd, FIONBIO, &asyncmode);
 
1349
  }
1308
1350
#else
1309
1351
  ret= fcntl(con->fd, F_GETFL, 0);
1310
1352
  if (ret == -1)