← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/conn.c

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

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)closesocket(con->fd);
 
89
  (void)close(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
 
  {
199
198
    con->options&= (drizzle_con_options_t)~DRIZZLE_CON_MYSQL;
200
 
  }
201
199
}
202
200
 
203
201
void drizzle_con_remove_options(drizzle_con_st *con,
453
451
  return drizzle_con_shutdown(con, result, ret_ptr);
454
452
}
455
453
 
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
 
 
466
454
drizzle_result_st *drizzle_con_ping(drizzle_con_st *con,
467
455
                                    drizzle_result_st *result,
468
456
                                    drizzle_return_t *ret_ptr)
485
473
                                             size_t total,
486
474
                                             drizzle_return_t *ret_ptr)
487
475
{
488
 
  drizzle_result_st *old_result;
489
 
 
490
476
  if (!(con->options & DRIZZLE_CON_READY))
491
477
  {
492
478
    if (con->options & DRIZZLE_CON_RAW_PACKET)
508
494
      con->result= NULL;
509
495
    else
510
496
    {
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
 
 
521
497
      con->result= drizzle_result_create(con, result);
522
498
      if (con->result == NULL)
523
499
      {
690
666
  size_t offset= 0;
691
667
  size_t size= 0;
692
668
 
693
 
  command_data= drizzle_con_command_read(con, command, &offset, &size, total, ret_ptr);
 
669
  command_data= drizzle_con_command_read(con, command, &offset, &size, total,
 
670
                                         ret_ptr);
694
671
  if (*ret_ptr != DRIZZLE_RETURN_OK)
695
672
    return NULL;
696
673
 
788
765
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);
789
766
    else
790
767
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
791
 
    port[NI_MAXSERV-1]= 0;
792
768
 
793
769
    memset(&ai, 0, sizeof(struct addrinfo));
794
770
    ai.ai_socktype= SOCK_STREAM;
795
771
    ai.ai_protocol= IPPROTO_TCP;
796
 
    ai.ai_flags = AI_PASSIVE;
797
 
    ai.ai_family = AF_UNSPEC;
798
772
 
799
773
    if (con->options & DRIZZLE_CON_LISTEN)
800
774
    {
 
775
      ai.ai_flags = AI_PASSIVE;
 
776
      ai.ai_family = AF_UNSPEC;
801
777
      host= tcp->host;
802
778
    }
803
779
    else
841
817
 
842
818
  if (con->fd != -1)
843
819
  {
844
 
    (void)closesocket(con->fd);
 
820
    (void)close(con->fd);
845
821
    con->fd= -1;
846
822
  }
847
823
 
877
853
                 con->addrinfo_next->ai_addrlen);
878
854
 
879
855
#ifdef _WIN32
 
856
    /*Mapping windows specific error codes to Posix*/
880
857
    errno = WSAGetLastError();
881
858
    switch(errno) {
882
859
    case WSAEINVAL:
883
860
    case WSAEALREADY:
884
861
    case WSAEWOULDBLOCK:
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;
 
862
      errno = EINPROGRESS;
907
863
      break;
908
864
    default:
909
865
      break;
1013
969
    read_size = recv(con->fd, (char *)con->buffer_ptr + con->buffer_size,
1014
970
                     available_buffer, 0);
1015
971
#ifdef _WIN32
 
972
    /*Get windows error codes and map it to Posix*/
1016
973
    errno = WSAGetLastError();
1017
974
    switch(errno) {
1018
 
    case WSAENOTCONN:
1019
975
    case WSAEWOULDBLOCK:
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;
 
976
    case 10057:
 
977
      errno = EAGAIN;
1046
978
      break;
1047
979
    default:
1048
980
      break;
1120
1052
  
1121
1053
    write_size = send(con->fd,(char *) con->buffer_ptr, con->buffer_size, 0);
1122
1054
 
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
 
 
1160
1055
    drizzle_log_crazy(con->drizzle, "write fd=%d return=%zd errno=%d", con->fd,
1161
1056
                      write_size, errno);
1162
1057
 
1250
1145
#endif /* _WIN32 */
1251
1146
    if (ret == -1)
1252
1147
    {
1253
 
      closesocket(fd);
 
1148
      close(fd);
1254
1149
      drizzle_set_error(con->drizzle, "drizzle_state_listen", "setsockopt:%d",
1255
1150
                        errno);
1256
1151
      return DRIZZLE_RETURN_ERRNO;
1259
1154
    ret= bind(fd, con->addrinfo_next->ai_addr, con->addrinfo_next->ai_addrlen);
1260
1155
    if (ret == -1)
1261
1156
    {
1262
 
      closesocket(fd);
 
1157
      close(fd);
1263
1158
      drizzle_set_error(con->drizzle, "drizzle_state_listen", "bind:%d", errno);
1264
1159
      if (errno == EADDRINUSE)
1265
1160
      {
1277
1172
 
1278
1173
    if (listen(fd, con->backlog) == -1)
1279
1174
    {
1280
 
      closesocket(fd);
 
1175
      close(fd);
1281
1176
      drizzle_set_error(con->drizzle, "drizzle_state_listen", "listen:%d",
1282
1177
                        errno);
1283
1178
      return DRIZZLE_RETURN_ERRNO;
1293
1188
      new_con= drizzle_con_clone(con->drizzle, NULL, con);
1294
1189
      if (new_con == NULL)
1295
1190
      {
1296
 
        closesocket(fd);
 
1191
        close(fd);
1297
1192
        return DRIZZLE_RETURN_MEMORY;
1298
1193
      }
1299
1194