61 static bool connect_poll(drizzle_con_st *con)
65 fds[0].events= POLLOUT;
70 int error= poll(fds, 1, con->drizzle->timeout);
76 socklen_t len=
sizeof (err);
79 if (getsockopt(con->fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0)
100 switch (get_socket_errno())
102 #ifdef TARGET_OS_LINUX
118 if (fds[0].revents & POLLERR)
121 socklen_t len=
sizeof (err);
122 (void)getsockopt(con->fd, SOL_SOCKET, SO_ERROR, &err, &len);
127 errno= get_socket_errno();
147 int drizzle_con_fd(
const drizzle_con_st *con)
157 drizzle_return_t drizzle_con_set_fd(drizzle_con_st *con,
int fd)
159 drizzle_return_t ret;
162 return DRIZZLE_RETURN_INVALID_ARGUMENT;
168 if (ret != DRIZZLE_RETURN_OK)
170 con->drizzle->last_errno= errno;
176 void drizzle_con_close(drizzle_con_st *con)
188 (void)closesocket(con->fd);
191 con->options&= int(~DRIZZLE_CON_READY);
192 con->packet_number= 0;
193 con->buffer_ptr= con->buffer;
201 drizzle_return_t drizzle_con_set_events(drizzle_con_st *con,
short events)
203 drizzle_return_t ret;
205 if ((con->events | events) == con->events)
207 return DRIZZLE_RETURN_OK;
210 con->events|= events;
212 if (con->drizzle->event_watch_fn != NULL)
214 ret= con->drizzle->event_watch_fn(con, con->events,
215 con->drizzle->event_watch_context);
216 if (ret != DRIZZLE_RETURN_OK)
218 drizzle_con_close(con);
223 return DRIZZLE_RETURN_OK;
226 drizzle_return_t drizzle_con_set_revents(drizzle_con_st *con,
short revents)
228 drizzle_return_t ret;
231 return DRIZZLE_RETURN_INVALID_ARGUMENT;
235 con->options|= DRIZZLE_CON_IO_READY;
237 con->revents= revents;
243 if (revents & POLLOUT && !(con->events & POLLOUT) &&
244 con->drizzle->event_watch_fn != NULL)
246 ret= con->drizzle->event_watch_fn(con, con->events,
247 con->drizzle->event_watch_context);
248 if (ret != DRIZZLE_RETURN_OK)
250 drizzle_con_close(con);
255 con->events&= (short)~revents;
257 return DRIZZLE_RETURN_OK;
260 drizzle_st *drizzle_con_drizzle(
const drizzle_con_st *con)
269 const char *drizzle_con_error(
const drizzle_con_st *con)
276 return drizzle_error(con->drizzle);
279 int drizzle_con_errno(
const drizzle_con_st *con)
286 return drizzle_errno(con->drizzle);
289 uint16_t drizzle_con_error_code(
const drizzle_con_st *con)
296 return drizzle_error_code(con->drizzle);
299 const char *drizzle_con_sqlstate(
const drizzle_con_st *con)
306 return drizzle_sqlstate(con->drizzle);
309 drizzle_con_options_t drizzle_con_options(
const drizzle_con_st *con)
313 return drizzle_con_options_t();
316 return drizzle_con_options_t(con->options);
319 void drizzle_con_set_options(drizzle_con_st *con,
320 drizzle_con_options_t options)
327 con->options= options;
330 void drizzle_con_add_options(drizzle_con_st *con,
331 drizzle_con_options_t options)
338 con->options|= options;
341 if (con->options & DRIZZLE_CON_EXPERIMENTAL)
343 con->options&= int(~DRIZZLE_CON_MYSQL);
347 void drizzle_con_remove_options(drizzle_con_st *con,
348 drizzle_con_options_t options)
355 con->options&= ~options;
358 const char *drizzle_con_host(
const drizzle_con_st *con)
365 if (con->socket_type == DRIZZLE_CON_SOCKET_TCP)
367 if (con->socket.tcp.host == NULL && !(con->options & DRIZZLE_CON_LISTEN))
368 return DRIZZLE_DEFAULT_TCP_HOST;
370 return con->socket.tcp.host;
376 in_port_t drizzle_con_port(
const drizzle_con_st *con)
378 if (con and con->socket_type == DRIZZLE_CON_SOCKET_TCP)
380 if (con->socket.tcp.port != 0)
382 return con->socket.tcp.port;
385 if (con->options & DRIZZLE_CON_MYSQL)
387 return DRIZZLE_DEFAULT_TCP_PORT_MYSQL;
390 return DRIZZLE_DEFAULT_TCP_PORT;
396 void drizzle_con_set_tcp(drizzle_con_st *con,
const char *host, in_port_t port)
405 con->socket_type= DRIZZLE_CON_SOCKET_TCP;
409 con->socket.tcp.host= NULL;
413 con->socket.tcp.host= con->socket.tcp.host_buffer;
414 strncpy(con->socket.tcp.host, host, NI_MAXHOST);
415 con->socket.tcp.host[NI_MAXHOST - 1]= 0;
418 con->socket.tcp.port= port;
421 const char *drizzle_con_user(
const drizzle_con_st *con)
431 const char *drizzle_con_password(
const drizzle_con_st *con)
438 return con->password;
441 void drizzle_con_set_auth(drizzle_con_st *con,
const char *user,
442 const char *password)
455 strncpy(con->user, user, DRIZZLE_MAX_USER_SIZE);
456 con->user[DRIZZLE_MAX_USER_SIZE - 1]= 0;
459 if (password == NULL)
465 strncpy(con->password, password, DRIZZLE_MAX_PASSWORD_SIZE);
466 con->password[DRIZZLE_MAX_PASSWORD_SIZE - 1]= 0;
470 const char *drizzle_con_db(
const drizzle_con_st *con)
480 void drizzle_con_set_db(drizzle_con_st *con,
const char *db)
493 strncpy(con->db, db, DRIZZLE_MAX_DB_SIZE);
494 con->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
498 void *drizzle_con_context(
const drizzle_con_st *con)
508 void drizzle_con_set_context(drizzle_con_st *con,
void *context)
515 con->context= context;
518 void drizzle_con_set_context_free_fn(drizzle_con_st *con,
519 drizzle_con_context_free_fn *
function)
526 con->context_free_fn=
function;
529 uint8_t drizzle_con_protocol_version(
const drizzle_con_st *con)
536 return con->protocol_version;
539 const char *drizzle_con_server_version(
const drizzle_con_st *con)
546 return con->server_version;
549 uint32_t drizzle_con_server_version_number(
const drizzle_con_st *con)
553 const char *current= con->server_version;
556 uint32_t major= (uint32_t)strtoul(current, &end, 10);
558 uint32_t minor= (uint32_t)strtoul(current, &end, 10);
560 uint32_t version= (uint32_t)strtoul(current, &end, 10);
562 return (major * 10000) +(minor * 100) +version;
568 uint32_t drizzle_con_thread_id(
const drizzle_con_st *con)
575 return con->thread_id;
578 const uint8_t *drizzle_con_scramble(
const drizzle_con_st *con)
585 return con->scramble;
588 drizzle_capabilities_t drizzle_con_capabilities(
const drizzle_con_st *con)
592 return drizzle_capabilities_t();
595 return drizzle_capabilities_t(con->capabilities);
598 drizzle_charset_t drizzle_con_charset(
const drizzle_con_st *con)
602 return drizzle_charset_t();
608 drizzle_con_status_t drizzle_con_status(
const drizzle_con_st *con)
612 return drizzle_con_status_t();
618 uint32_t drizzle_con_max_packet_size(
const drizzle_con_st *con)
625 return con->max_packet_size;
632 drizzle_return_t drizzle_con_connect(drizzle_con_st *con)
636 return DRIZZLE_RETURN_INVALID_ARGUMENT;
639 if (con->options & DRIZZLE_CON_READY)
641 return DRIZZLE_RETURN_OK;
646 if (!(con->options & DRIZZLE_CON_RAW_PACKET))
659 drizzle_result_st *drizzle_con_quit(drizzle_con_st *con,
660 drizzle_result_st *result,
661 drizzle_return_t *ret_ptr)
663 return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUIT, NULL, 0,
667 drizzle_result_st *drizzle_quit(drizzle_con_st *con,
668 drizzle_result_st *result,
669 drizzle_return_t *ret_ptr)
671 return drizzle_con_quit(con, result, ret_ptr);
674 drizzle_result_st *drizzle_con_select_db(drizzle_con_st *con,
675 drizzle_result_st *result,
677 drizzle_return_t *ret_ptr)
679 drizzle_con_set_db(con, db);
680 return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_INIT_DB,
681 db, strlen(db), strlen(db), ret_ptr);
684 drizzle_result_st *drizzle_select_db(drizzle_con_st *con,
685 drizzle_result_st *result,
687 drizzle_return_t *ret_ptr)
689 return drizzle_con_select_db(con, result, db, ret_ptr);
692 drizzle_result_st *drizzle_con_shutdown(drizzle_con_st *con,
693 drizzle_result_st *result,
694 drizzle_return_t *ret_ptr)
696 drizzle_return_t unused;
702 if (con and con->options & DRIZZLE_CON_MYSQL)
704 return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_SHUTDOWN,
708 return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_SHUTDOWN, NULL,
712 drizzle_result_st *drizzle_shutdown(drizzle_con_st *con,
713 drizzle_result_st *result, uint32_t,
714 drizzle_return_t *ret_ptr)
716 return drizzle_con_shutdown(con, result, ret_ptr);
719 drizzle_result_st *drizzle_kill(drizzle_con_st *con,
720 drizzle_result_st *result,
722 drizzle_return_t *ret_ptr)
724 drizzle_return_t unused;
730 uint32_t sent= htonl(query_id);
731 return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_PROCESS_KILL,
732 &sent,
sizeof(uint32_t),
sizeof(uint32_t), ret_ptr);
735 drizzle_result_st *drizzle_con_ping(drizzle_con_st *con,
736 drizzle_result_st *result,
737 drizzle_return_t *ret_ptr)
739 return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_PING, NULL, 0,
743 drizzle_result_st *drizzle_ping(drizzle_con_st *con,
744 drizzle_result_st *result,
745 drizzle_return_t *ret_ptr)
747 return drizzle_con_ping(con, result, ret_ptr);
750 drizzle_result_st *drizzle_con_command_write(drizzle_con_st *con,
751 drizzle_result_st *result,
752 drizzle_command_t command,
753 const void *data,
size_t size,
755 drizzle_return_t *ret_ptr)
757 drizzle_return_t unused;
765 *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
769 drizzle_result_st *old_result;
771 if (!(con->options & DRIZZLE_CON_READY))
773 if (con->options & DRIZZLE_CON_RAW_PACKET)
776 "connection not ready");
777 *ret_ptr= DRIZZLE_RETURN_NOT_READY;
781 *ret_ptr= drizzle_con_connect(con);
782 if (*ret_ptr != DRIZZLE_RETURN_OK)
790 if (con->options & (DRIZZLE_CON_RAW_PACKET | DRIZZLE_CON_NO_RESULT_READ))
796 for (old_result= con->result_list; old_result != NULL; old_result= old_result->next)
798 if (result == old_result)
800 drizzle_set_error(con->drizzle,
"drizzle_command_write",
"result struct already in use");
801 *ret_ptr= DRIZZLE_RETURN_INTERNAL_ERROR;
806 con->result= drizzle_result_create(con, result);
807 if (con->result == NULL)
809 *ret_ptr= DRIZZLE_RETURN_MEMORY;
814 con->command= command;
815 con->command_data= (uint8_t *)data;
816 con->command_size= size;
817 con->command_offset= 0;
818 con->command_total= total;
822 else if (con->command_data == NULL)
824 con->command_data= (uint8_t *)data;
825 con->command_size= size;
829 if (*ret_ptr == DRIZZLE_RETURN_PAUSE)
831 *ret_ptr= DRIZZLE_RETURN_OK;
833 else if (*ret_ptr != DRIZZLE_RETURN_OK &&
834 *ret_ptr != DRIZZLE_RETURN_IO_WAIT &&
835 *ret_ptr != DRIZZLE_RETURN_ERROR_CODE)
837 drizzle_result_free(con->result);
848 drizzle_return_t drizzle_con_listen(drizzle_con_st *con)
852 return DRIZZLE_RETURN_INVALID_ARGUMENT;
855 if (con->options & DRIZZLE_CON_READY)
857 return DRIZZLE_RETURN_OK;
869 int drizzle_con_backlog(
const drizzle_con_st *con)
879 void drizzle_con_set_backlog(drizzle_con_st *con,
int backlog)
886 con->backlog= backlog;
889 void drizzle_con_set_protocol_version(drizzle_con_st *con,
890 uint8_t protocol_version)
897 con->protocol_version= protocol_version;
900 void drizzle_con_set_server_version(drizzle_con_st *con,
901 const char *server_version)
908 if (server_version == NULL)
910 con->server_version[0]= 0;
914 strncpy(con->server_version, server_version,
915 DRIZZLE_MAX_SERVER_VERSION_SIZE);
916 con->server_version[DRIZZLE_MAX_SERVER_VERSION_SIZE - 1]= 0;
920 void drizzle_con_set_thread_id(drizzle_con_st *con, uint32_t thread_id)
927 con->thread_id= thread_id;
930 void drizzle_con_set_scramble(drizzle_con_st *con,
const uint8_t *scramble)
937 if (scramble == NULL)
943 con->scramble= con->scramble_buffer;
944 memcpy(con->scramble, scramble, DRIZZLE_MAX_SCRAMBLE_SIZE);
948 void drizzle_con_set_capabilities(drizzle_con_st *con,
949 drizzle_capabilities_t capabilities)
956 con->capabilities= capabilities;
959 void drizzle_con_set_charset(drizzle_con_st *con, drizzle_charset_t charset)
966 con->charset= charset;
969 void drizzle_con_set_status(drizzle_con_st *con, drizzle_con_status_t status)
979 void drizzle_con_set_max_packet_size(drizzle_con_st *con,
980 uint32_t max_packet_size)
987 con->max_packet_size= max_packet_size;
990 void drizzle_con_copy_handshake(drizzle_con_st *con, drizzle_con_st *from)
992 drizzle_con_set_auth(con, from->user, NULL);
993 drizzle_con_set_scramble(con, from->scramble);
994 drizzle_con_set_db(con, from->db);
995 drizzle_con_set_protocol_version(con, from->protocol_version);
996 drizzle_con_set_server_version(con, from->server_version);
997 drizzle_con_set_thread_id(con, from->thread_id);
998 drizzle_con_set_scramble(con, from->scramble);
999 drizzle_con_set_capabilities(con, drizzle_capabilities_t(from->capabilities));
1000 drizzle_con_set_charset(con, from->charset);
1001 drizzle_con_set_status(con, from->status);
1002 drizzle_con_set_max_packet_size(con, from->max_packet_size);
1005 void *drizzle_con_command_read(drizzle_con_st *con,
1006 drizzle_command_t *command,
size_t *offset,
1007 size_t *size,
size_t *total,
1008 drizzle_return_t *ret_ptr)
1010 drizzle_return_t unused_ret;
1011 if (ret_ptr == NULL)
1013 ret_ptr= &unused_ret;
1018 *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
1024 con->packet_number= 0;
1025 con->command_offset= 0;
1026 con->command_total= 0;
1034 *offset= con->command_offset;
1038 if (*ret_ptr == DRIZZLE_RETURN_PAUSE)
1040 *ret_ptr= DRIZZLE_RETURN_OK;
1045 *command= con->command;
1050 *size= con->command_size;
1055 *total= con->command_total;
1058 return con->command_data;
1061 void *drizzle_con_command_buffer(drizzle_con_st *con,
1062 drizzle_command_t *command,
size_t *total,
1063 drizzle_return_t *ret_ptr)
1068 drizzle_return_t unused_ret;
1069 if (ret_ptr == NULL)
1071 ret_ptr= &unused_ret;
1074 size_t unused_total;
1077 total= &unused_total;
1082 *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
1086 char *command_data= (
char *)drizzle_con_command_read(con, command, &offset, &size, total, ret_ptr);
1087 if (*ret_ptr != DRIZZLE_RETURN_OK)
1092 if (command_data == NULL)
1098 if (con->command_buffer == NULL)
1100 con->command_buffer= (uint8_t*)realloc(NULL, (*total) +1);
1101 if (con->command_buffer == NULL)
1104 *ret_ptr= DRIZZLE_RETURN_MEMORY;
1109 memcpy(con->command_buffer + offset, command_data, size);
1111 while ((offset + size) != (*total))
1113 command_data= (
char *)drizzle_con_command_read(con, command, &offset, &size, total, ret_ptr);
1114 if (*ret_ptr != DRIZZLE_RETURN_OK)
1119 memcpy(con->command_buffer + offset, command_data, size);
1122 command_data= (
char *)con->command_buffer;
1123 con->command_buffer= NULL;
1124 command_data[*total]= 0;
1126 return command_data;
1140 switch (con->socket_type)
1142 case DRIZZLE_CON_SOCKET_TCP:
1143 if (con->socket.tcp.addrinfo != NULL)
1145 freeaddrinfo(con->socket.tcp.addrinfo);
1146 con->socket.tcp.addrinfo= NULL;
1150 case DRIZZLE_CON_SOCKET_UDS:
1151 con->socket.uds.path_buffer[0]= 0;
1158 con->addrinfo_next= NULL;
1165 drizzle_return_t drizzle_state_addrinfo(drizzle_con_st *con)
1167 drizzle_con_tcp_st *tcp;
1169 char port[NI_MAXSERV];
1175 return DRIZZLE_RETURN_INVALID_ARGUMENT;
1180 switch (con->socket_type)
1182 case DRIZZLE_CON_SOCKET_TCP:
1183 tcp= &(con->socket.tcp);
1185 if (tcp->addrinfo != NULL)
1187 freeaddrinfo(tcp->addrinfo);
1188 tcp->addrinfo= NULL;
1193 snprintf(port, NI_MAXSERV,
"%u", tcp->port);
1195 else if (con->options & DRIZZLE_CON_MYSQL)
1197 snprintf(port, NI_MAXSERV,
"%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);
1201 snprintf(port, NI_MAXSERV,
"%u", DRIZZLE_DEFAULT_TCP_PORT);
1203 port[NI_MAXSERV-1]= 0;
1205 memset(&ai, 0,
sizeof(
struct addrinfo));
1206 ai.ai_socktype= SOCK_STREAM;
1207 ai.ai_protocol= IPPROTO_TCP;
1208 ai.ai_flags = AI_PASSIVE;
1209 ai.ai_family = AF_UNSPEC;
1211 if (con->options & DRIZZLE_CON_LISTEN)
1217 if (tcp->host == NULL)
1219 host= DRIZZLE_DEFAULT_TCP_HOST;
1227 ret= getaddrinfo(host, port, &ai, &(tcp->addrinfo));
1230 drizzle_set_error(con->drizzle,
"drizzle_state_addrinfo",
"getaddrinfo:%s", gai_strerror(ret));
1231 return DRIZZLE_RETURN_GETADDRINFO;
1234 con->addrinfo_next= tcp->addrinfo;
1238 case DRIZZLE_CON_SOCKET_UDS:
1246 return DRIZZLE_RETURN_OK;
1249 drizzle_return_t drizzle_state_connect(drizzle_con_st *con)
1252 drizzle_return_t dret;
1256 return DRIZZLE_RETURN_INVALID_ARGUMENT;
1263 (void)closesocket(con->fd);
1267 if (con->socket_type == DRIZZLE_CON_SOCKET_UDS)
1270 if ((con->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
1272 con->drizzle->last_errno= errno;
1273 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1276 struct sockaddr_un servAddr;
1278 memset(&servAddr, 0,
sizeof (
struct sockaddr_un));
1279 servAddr.sun_family= AF_UNIX;
1280 strncpy(servAddr.sun_path, con->socket.uds.path_buffer,
sizeof(servAddr.sun_path));
1283 if (connect(con->fd, (
struct sockaddr *)&servAddr,
sizeof(servAddr)) < 0)
1298 con->drizzle->last_errno= errno;
1299 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1306 return DRIZZLE_RETURN_OK;
1308 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1313 if (con->addrinfo_next == NULL)
1317 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1320 con->fd= socket(con->addrinfo_next->ai_family,
1321 con->addrinfo_next->ai_socktype,
1322 con->addrinfo_next->ai_protocol);
1326 con->drizzle->last_errno= errno;
1327 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1331 if (dret != DRIZZLE_RETURN_OK)
1333 con->drizzle->last_errno= errno;
1334 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1339 ret= connect(con->fd, con->addrinfo_next->ai_addr,
1340 con->addrinfo_next->ai_addrlen);
1343 errno = WSAGetLastError();
1347 case WSAEWOULDBLOCK:
1350 case WSAECONNREFUSED:
1351 errno= ECONNREFUSED;
1353 case WSAENETUNREACH:
1368 case WSAENOPROTOOPT:
1376 drizzle_log_crazy(con->drizzle,
"connect return=%d errno=%s", ret, strerror(errno));
1380 con->addrinfo_next= NULL;
1384 if (errno == EAGAIN || errno == EINTR)
1389 if (errno == EINPROGRESS)
1391 if (connect_poll(con))
1394 return DRIZZLE_RETURN_OK;
1397 else if (errno == ECONNREFUSED || errno == ENETUNREACH || errno == ETIMEDOUT)
1399 con->addrinfo_next= con->addrinfo_next->ai_next;
1400 return DRIZZLE_RETURN_OK;
1404 con->drizzle->last_errno= errno;
1405 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1410 SSL_set_fd(con->ssl, con->fd);
1416 return DRIZZLE_RETURN_OK;
1419 drizzle_return_t drizzle_state_connecting(drizzle_con_st *con)
1421 drizzle_return_t ret;
1425 return DRIZZLE_RETURN_INVALID_ARGUMENT;
1433 if (con->revents & POLLOUT)
1436 socklen_t error_length=
sizeof(error);
1437 int getsockopt_error;
1438 if ((getsockopt_error= getsockopt(con->fd, SOL_SOCKET, SO_ERROR, (
void*)&error, &error_length)) < 1)
1441 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1447 return DRIZZLE_RETURN_OK;
1450 else if (con->revents & (POLLERR | POLLHUP | POLLNVAL))
1460 con->addrinfo_next= con->addrinfo_next->ai_next;
1461 return DRIZZLE_RETURN_OK;
1464 ret= drizzle_con_set_events(con, POLLOUT);
1465 if (ret != DRIZZLE_RETURN_OK)
1470 if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1472 return DRIZZLE_RETURN_IO_WAIT;
1475 ret= drizzle_con_wait(con->drizzle);
1476 if (ret != DRIZZLE_RETURN_OK)
1483 drizzle_return_t drizzle_state_read(drizzle_con_st *con)
1485 drizzle_return_t ret;
1490 return DRIZZLE_RETURN_INVALID_ARGUMENT;
1495 if (con->buffer_size == 0)
1496 con->buffer_ptr= con->buffer;
1497 else if ((con->buffer_ptr - con->buffer) > (DRIZZLE_MAX_BUFFER_SIZE / 2))
1499 memmove(con->buffer, con->buffer_ptr, con->buffer_size);
1500 con->buffer_ptr= con->buffer;
1503 if ((con->revents & POLLIN) == 0 &&
1504 (con->drizzle->options & DRIZZLE_NON_BLOCKING))
1509 ret= drizzle_con_set_events(con, POLLIN);
1510 if (ret != DRIZZLE_RETURN_OK)
1512 return DRIZZLE_RETURN_IO_WAIT;
1517 size_t available_buffer= (size_t)DRIZZLE_MAX_BUFFER_SIZE -
1518 ((
size_t)(con->buffer_ptr - con->buffer) + con->buffer_size);
1520 if (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE)
1521 read_size= SSL_read(con->ssl, (
char*)con->buffer_ptr + con->buffer_size, available_buffer);
1523 read_size = recv(con->fd, (
char *)con->buffer_ptr + con->buffer_size,
1524 available_buffer, 0);
1526 errno = WSAGetLastError();
1529 case WSAEWOULDBLOCK:
1536 case WSAECONNREFUSED:
1537 errno= ECONNREFUSED;
1539 case WSAENETUNREACH:
1554 case WSAENOPROTOOPT:
1563 (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE) ? 1 : 0,
1569 "%s:%d lost connection to server (EOF)", __FILE__, __LINE__);
1570 return DRIZZLE_RETURN_LOST_CONNECTION;
1572 else if (read_size == -1)
1574 if (errno == EAGAIN)
1577 con->revents&= ~POLLIN;
1578 ret= drizzle_con_set_events(con, POLLIN);
1579 if (ret != DRIZZLE_RETURN_OK)
1582 if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1583 return DRIZZLE_RETURN_IO_WAIT;
1585 ret= drizzle_con_wait(con->drizzle);
1586 if (ret != DRIZZLE_RETURN_OK)
1591 else if (errno == ECONNREFUSED)
1596 con->addrinfo_next= con->addrinfo_next->ai_next;
1597 return DRIZZLE_RETURN_OK;
1599 else if (errno == EINTR)
1603 else if (errno == EPIPE || errno == ECONNRESET)
1606 "%s:%d lost connection to server (%s)",
1607 __FILE__, __LINE__, strerror(errno));
1608 return DRIZZLE_RETURN_LOST_CONNECTION;
1612 con->drizzle->last_errno= errno;
1613 return DRIZZLE_RETURN_ERRNO;
1617 if ((
size_t) read_size < available_buffer)
1619 con->revents&= ~POLLIN;
1621 con->buffer_size+= (size_t)read_size;
1627 return DRIZZLE_RETURN_OK;
1630 drizzle_return_t drizzle_state_write(drizzle_con_st *con)
1632 drizzle_return_t ret;
1637 return DRIZZLE_RETURN_INVALID_ARGUMENT;
1642 while (con->buffer_size != 0)
1644 if (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE)
1645 write_size= SSL_write(con->ssl, con->buffer_ptr, con->buffer_size);
1647 write_size = send(con->fd,(
char *) con->buffer_ptr, con->buffer_size, 0);
1650 errno = WSAGetLastError();
1653 case WSAEWOULDBLOCK:
1660 case WSAECONNREFUSED:
1661 errno= ECONNREFUSED;
1663 case WSAENETUNREACH:
1678 case WSAENOPROTOOPT:
1687 con->fd, write_size,
1688 (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE) ? 1 : 0,
1691 if (write_size == 0)
1693 else if (write_size == -1)
1695 if (errno == EAGAIN)
1697 ret= drizzle_con_set_events(con, POLLOUT);
1698 if (ret != DRIZZLE_RETURN_OK)
1703 if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1705 return DRIZZLE_RETURN_IO_WAIT;
1708 ret= drizzle_con_wait(con->drizzle);
1709 if (ret != DRIZZLE_RETURN_OK)
1716 else if (errno == EINTR)
1720 else if (errno == EPIPE || errno == ECONNRESET)
1722 drizzle_set_error(con->drizzle, __func__,
"%s:%d lost connection to server (%s)",
1723 __FILE__, __LINE__, strerror(errno));
1724 return DRIZZLE_RETURN_LOST_CONNECTION;
1727 drizzle_set_error(con->drizzle,
"drizzle_state_write",
"write:%s", strerror(errno));
1728 con->drizzle->last_errno= errno;
1729 return DRIZZLE_RETURN_ERRNO;
1732 con->buffer_ptr+= write_size;
1733 con->buffer_size-= (size_t)write_size;
1734 if (con->buffer_size == 0)
1738 con->buffer_ptr= con->buffer;
1742 return DRIZZLE_RETURN_OK;
1745 drizzle_return_t drizzle_state_listen(drizzle_con_st *con)
1747 char host[NI_MAXHOST];
1748 char port[NI_MAXSERV];
1751 drizzle_con_st *new_con;
1755 return DRIZZLE_RETURN_INVALID_ARGUMENT;
1758 for (; con->addrinfo_next != NULL;
1759 con->addrinfo_next= con->addrinfo_next->ai_next)
1761 int ret= getnameinfo(con->addrinfo_next->ai_addr,
1762 con->addrinfo_next->ai_addrlen, host, NI_MAXHOST, port,
1763 NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV);
1767 return DRIZZLE_RETURN_GETADDRINFO;
1771 fd= socket(con->addrinfo_next->ai_family, con->addrinfo_next->ai_socktype,
1772 con->addrinfo_next->ai_protocol);
1782 ret= setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,(
const char*) &opt,
sizeof(opt));
1784 ret= setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt,
sizeof(opt));
1790 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1793 ret= bind(fd, con->addrinfo_next->ai_addr, con->addrinfo_next->ai_addrlen);
1798 if (errno == EADDRINUSE)
1809 return DRIZZLE_RETURN_ERRNO;
1812 if (listen(fd, con->backlog) == -1)
1816 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1826 new_con= drizzle_con_clone(con->drizzle, NULL, con);
1827 if (new_con == NULL)
1830 return DRIZZLE_RETURN_MEMORY;
1837 drizzle_return_t local_ret= drizzle_con_set_events(new_con, POLLIN);
1838 if (local_ret != DRIZZLE_RETURN_OK)
1840 drizzle_con_free(new_con);
1850 return DRIZZLE_RETURN_COULD_NOT_CONNECT;
1855 return DRIZZLE_RETURN_OK;
1864 struct linger linger;
1865 struct timeval waittime;
1872 ret= setsockopt(con->fd, IPPROTO_TCP, TCP_NODELAY, (
const char*)&ret, (socklen_t)
sizeof(
int));
1874 ret= setsockopt(con->fd, IPPROTO_TCP, TCP_NODELAY, &ret, (socklen_t)
sizeof(
int));
1877 if (ret == -1 && errno != EOPNOTSUPP)
1879 drizzle_set_error(con->drizzle, __func__,
"setsockopt:TCP_NODELAY:%s", strerror(errno));
1880 return DRIZZLE_RETURN_ERRNO;
1884 linger.l_linger= DRIZZLE_DEFAULT_SOCKET_TIMEOUT;
1887 ret= setsockopt(con->fd, SOL_SOCKET, SO_LINGER, (
const char*)&linger,
1888 (socklen_t)
sizeof(
struct linger));
1890 ret= setsockopt(con->fd, SOL_SOCKET, SO_LINGER, &linger,
1891 (socklen_t)
sizeof(
struct linger));
1896 drizzle_set_error(con->drizzle, __func__,
"setsockopt:SO_LINGER:%s", strerror(errno));
1897 return DRIZZLE_RETURN_ERRNO;
1900 waittime.tv_sec= DRIZZLE_DEFAULT_SOCKET_TIMEOUT;
1901 waittime.tv_usec= 0;
1904 ret= setsockopt(con->fd, SOL_SOCKET, SO_SNDTIMEO, (
const char*)&waittime,
1905 (socklen_t)
sizeof(
struct timeval));
1907 ret= setsockopt(con->fd, SOL_SOCKET, SO_SNDTIMEO, &waittime,
1908 (socklen_t)
sizeof(
struct timeval));
1911 if (ret == -1 && errno != ENOPROTOOPT)
1913 drizzle_set_error(con->drizzle, __func__,
"setsockopt:SO_SNDTIMEO:%s", strerror(errno));
1914 return DRIZZLE_RETURN_ERRNO;
1918 ret= setsockopt(con->fd, SOL_SOCKET, SO_RCVTIMEO, (
const char*)&waittime,
1919 (socklen_t)
sizeof(
struct timeval));
1921 ret= setsockopt(con->fd, SOL_SOCKET, SO_RCVTIMEO, &waittime,
1922 (socklen_t)
sizeof(
struct timeval));
1925 if (ret == -1 && errno != ENOPROTOOPT)
1928 "setsockopt:SO_RCVTIMEO:%s", strerror(errno));
1929 return DRIZZLE_RETURN_ERRNO;
1932 ret= DRIZZLE_DEFAULT_SOCKET_SEND_SIZE;
1934 ret= setsockopt(con->fd, SOL_SOCKET, SO_SNDBUF, (
const char*)&ret, (socklen_t)
sizeof(
int));
1936 ret= setsockopt(con->fd, SOL_SOCKET, SO_SNDBUF, &ret, (socklen_t)
sizeof(
int));
1940 drizzle_set_error(con->drizzle, __func__,
"setsockopt:SO_SNDBUF:%s", strerror(errno));
1941 return DRIZZLE_RETURN_ERRNO;
1944 ret= DRIZZLE_DEFAULT_SOCKET_RECV_SIZE;
1946 ret= setsockopt(con->fd, SOL_SOCKET, SO_RCVBUF, (
const char*)&ret, (socklen_t)
sizeof(
int));
1948 ret= setsockopt(con->fd, SOL_SOCKET, SO_RCVBUF, &ret, (socklen_t)
sizeof(
int));
1952 drizzle_set_error(con->drizzle, __func__,
"setsockopt:SO_RCVBUF:%s", strerror(errno));
1953 return DRIZZLE_RETURN_ERRNO;
1956 #if defined (_WIN32)
1958 unsigned long asyncmode;
1960 ioctlsocket(con->fd, FIONBIO, &asyncmode);
1965 ret= fcntl(con->fd, F_GETFL, 0);
1969 return DRIZZLE_RETURN_ERRNO;
1972 ret= fcntl(con->fd, F_SETFL, ret | O_NONBLOCK);
1976 return DRIZZLE_RETURN_ERRNO;
1981 return DRIZZLE_RETURN_OK;
static void drizzle_state_reset(drizzle_con_st *con)
static void drizzle_state_pop(drizzle_con_st *con)
static bool drizzle_state_none(drizzle_con_st *con)
static drizzle_return_t _con_setsockopt(drizzle_con_st *con)
static void drizzle_log_crazy(drizzle_st *drizzle, const char *format,...)
static void drizzle_state_push(drizzle_con_st *con, drizzle_state_fn *function)
void drizzle_con_reset_addrinfo(drizzle_con_st *con)
void drizzle_set_error(drizzle_st *drizzle, const char *function, const char *format,...)
drizzle_return_t drizzle_state_loop(drizzle_con_st *con)
static void drizzle_log_debug(drizzle_st *drizzle, const char *format,...)
static void drizzle_log_info(drizzle_st *drizzle, const char *format,...)