← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-1.0/libdrizzle/conn.c

  • Committer: pcrews
  • Date: 2011-05-24 17:36:24 UTC
  • mfrom: (1099.4.232 drizzle)
  • Revision ID: pcrews@lucid32-20110524173624-mwr1bvq6fa1r01ao
Updated translations + 2011.05.18 tarball tag

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-1.0/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
 
765
788
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);
766
789
    else
767
790
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
 
791
    port[NI_MAXSERV-1]= 0;
768
792
 
769
793
    memset(&ai, 0, sizeof(struct addrinfo));
770
794
    ai.ai_socktype= SOCK_STREAM;
771
795
    ai.ai_protocol= IPPROTO_TCP;
 
796
    ai.ai_flags = AI_PASSIVE;
 
797
    ai.ai_family = AF_UNSPEC;
772
798
 
773
799
    if (con->options & DRIZZLE_CON_LISTEN)
774
800
    {
775
 
      ai.ai_flags = AI_PASSIVE;
776
 
      ai.ai_family = AF_UNSPEC;
777
801
      host= tcp->host;
778
802
    }
779
803
    else
817
841
 
818
842
  if (con->fd != -1)
819
843
  {
820
 
    (void)close(con->fd);
 
844
    (void)closesocket(con->fd);
821
845
    con->fd= -1;
822
846
  }
823
847
 
853
877
                 con->addrinfo_next->ai_addrlen);
854
878
 
855
879
#ifdef _WIN32
856
 
    /*Mapping windows specific error codes to Posix*/
857
880
    errno = WSAGetLastError();
858
881
    switch(errno) {
859
882
    case WSAEINVAL:
860
883
    case WSAEALREADY:
861
884
    case WSAEWOULDBLOCK:
862
 
      errno = EINPROGRESS;
 
885
      errno= EINPROGRESS;
 
886
      break;
 
887
    case WSAECONNREFUSED:
 
888
      errno= ECONNREFUSED;
 
889
      break;
 
890
    case WSAENETUNREACH:
 
891
      errno= ENETUNREACH;
 
892
      break;
 
893
    case WSAETIMEDOUT:
 
894
      errno= ETIMEDOUT;
 
895
      break;
 
896
    case WSAECONNRESET:
 
897
      errno= ECONNRESET;
 
898
      break;
 
899
    case WSAEADDRINUSE:
 
900
      errno= EADDRINUSE;
 
901
      break;
 
902
    case WSAEOPNOTSUPP:
 
903
      errno= EOPNOTSUPP;
 
904
      break;
 
905
    case WSAENOPROTOOPT:
 
906
      errno= ENOPROTOOPT;
863
907
      break;
864
908
    default:
865
909
      break;
969
1013
    read_size = recv(con->fd, (char *)con->buffer_ptr + con->buffer_size,
970
1014
                     available_buffer, 0);
971
1015
#ifdef _WIN32
972
 
    /*Get windows error codes and map it to Posix*/
973
1016
    errno = WSAGetLastError();
974
1017
    switch(errno) {
 
1018
    case WSAENOTCONN:
975
1019
    case WSAEWOULDBLOCK:
976
 
    case 10057:
977
 
      errno = EAGAIN;
 
1020
      errno= EAGAIN;
 
1021
      break;
 
1022
    case WSAEINVAL:
 
1023
    case WSAEALREADY:
 
1024
      errno= EINPROGRESS;
 
1025
      break;
 
1026
    case WSAECONNREFUSED:
 
1027
      errno= ECONNREFUSED;
 
1028
      break;
 
1029
    case WSAENETUNREACH:
 
1030
      errno= ENETUNREACH;
 
1031
      break;
 
1032
    case WSAETIMEDOUT:
 
1033
      errno= ETIMEDOUT;
 
1034
      break;
 
1035
    case WSAECONNRESET:
 
1036
      errno= ECONNRESET;
 
1037
      break;
 
1038
    case WSAEADDRINUSE:
 
1039
      errno= EADDRINUSE;
 
1040
      break;
 
1041
    case WSAEOPNOTSUPP:
 
1042
      errno= EOPNOTSUPP;
 
1043
      break;
 
1044
    case WSAENOPROTOOPT:
 
1045
      errno= ENOPROTOOPT;
978
1046
      break;
979
1047
    default:
980
1048
      break;
1052
1120
  
1053
1121
    write_size = send(con->fd,(char *) con->buffer_ptr, con->buffer_size, 0);
1054
1122
 
 
1123
#ifdef _WIN32
 
1124
    errno = WSAGetLastError();
 
1125
    switch(errno) {
 
1126
    case WSAENOTCONN:
 
1127
    case WSAEWOULDBLOCK:
 
1128
      errno= EAGAIN;
 
1129
      break;
 
1130
    case WSAEINVAL:
 
1131
    case WSAEALREADY:
 
1132
      errno= EINPROGRESS;
 
1133
      break;
 
1134
    case WSAECONNREFUSED:
 
1135
      errno= ECONNREFUSED;
 
1136
      break;
 
1137
    case WSAENETUNREACH:
 
1138
      errno= ENETUNREACH;
 
1139
      break;
 
1140
    case WSAETIMEDOUT:
 
1141
      errno= ETIMEDOUT;
 
1142
      break;
 
1143
    case WSAECONNRESET:
 
1144
      errno= ECONNRESET;
 
1145
      break;
 
1146
    case WSAEADDRINUSE:
 
1147
      errno= EADDRINUSE;
 
1148
      break;
 
1149
    case WSAEOPNOTSUPP:
 
1150
      errno= EOPNOTSUPP;
 
1151
      break;
 
1152
    case WSAENOPROTOOPT:
 
1153
      errno= ENOPROTOOPT;
 
1154
      break;
 
1155
    default:
 
1156
      break;
 
1157
    }
 
1158
#endif /* _WIN32 */     
 
1159
 
1055
1160
    drizzle_log_crazy(con->drizzle, "write fd=%d return=%zd errno=%d", con->fd,
1056
1161
                      write_size, errno);
1057
1162
 
1145
1250
#endif /* _WIN32 */
1146
1251
    if (ret == -1)
1147
1252
    {
1148
 
      close(fd);
 
1253
      closesocket(fd);
1149
1254
      drizzle_set_error(con->drizzle, "drizzle_state_listen", "setsockopt:%d",
1150
1255
                        errno);
1151
1256
      return DRIZZLE_RETURN_ERRNO;
1154
1259
    ret= bind(fd, con->addrinfo_next->ai_addr, con->addrinfo_next->ai_addrlen);
1155
1260
    if (ret == -1)
1156
1261
    {
1157
 
      close(fd);
 
1262
      closesocket(fd);
1158
1263
      drizzle_set_error(con->drizzle, "drizzle_state_listen", "bind:%d", errno);
1159
1264
      if (errno == EADDRINUSE)
1160
1265
      {
1172
1277
 
1173
1278
    if (listen(fd, con->backlog) == -1)
1174
1279
    {
1175
 
      close(fd);
 
1280
      closesocket(fd);
1176
1281
      drizzle_set_error(con->drizzle, "drizzle_state_listen", "listen:%d",
1177
1282
                        errno);
1178
1283
      return DRIZZLE_RETURN_ERRNO;
1188
1293
      new_con= drizzle_con_clone(con->drizzle, NULL, con);
1189
1294
      if (new_con == NULL)
1190
1295
      {
1191
 
        close(fd);
 
1296
        closesocket(fd);
1192
1297
        return DRIZZLE_RETURN_MEMORY;
1193
1298
      }
1194
1299