← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/libdrizzle/conn.cc

  • Committer: Mark Atwood
  • Date: 2011-10-08 04:50:51 UTC
  • mfrom: (2430.1.1 rf)
  • Revision ID: me@mark.atwood.name-20111008045051-6ha1qiy7k2a9c3jv
Tags: 2011.10.27
merge lp:~olafvdspek/drizzle/refactor2

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/libdrizzle/conn.cc
40
40
 * @brief Connection Definitions
41
41
 */
42
42
 
43
 
#include <libdrizzle-2.0/common.h>
 
43
#include "common.h"
44
44
 
45
45
/**
46
46
 * @addtogroup drizzle_con_static Static Connection Declarations
176
176
  return con->options;
177
177
}
178
178
 
179
 
void drizzle_con_set_options(drizzle_con_st *con, int options)
 
179
void drizzle_con_set_options(drizzle_con_st *con,
 
180
                             int options)
180
181
{
181
182
  con->options= options;
182
183
}
183
184
 
184
 
void drizzle_con_add_options(drizzle_con_st *con, int options)
 
185
void drizzle_con_add_options(drizzle_con_st *con,
 
186
                             int options)
185
187
{
186
188
  con->options|= options;
187
189
 
188
190
  /* If asking for the experimental Drizzle protocol, clean the MySQL flag. */
189
191
  if (con->options & DRIZZLE_CON_EXPERIMENTAL)
190
 
  {
191
192
    con->options&= ~DRIZZLE_CON_MYSQL;
192
 
  }
193
193
}
194
194
 
195
 
void drizzle_con_remove_options(drizzle_con_st *con, int options)
 
195
void drizzle_con_remove_options(drizzle_con_st *con,
 
196
                                int options)
196
197
{
197
198
  con->options&= ~options;
198
199
}
199
200
 
200
201
const char *drizzle_con_host(const drizzle_con_st *con)
201
202
{
202
 
  if (con == NULL)
203
 
  {
204
 
    return NULL;
205
 
  }
206
 
 
207
203
  if (con->socket_type == DRIZZLE_CON_SOCKET_TCP)
208
204
  {
209
205
    if (con->socket.tcp.host == NULL && !(con->options & DRIZZLE_CON_LISTEN))
210
 
    {
211
206
      return DRIZZLE_DEFAULT_TCP_HOST;
212
 
    }
213
207
 
214
208
    return con->socket.tcp.host;
215
209
  }
240
234
  con->socket_type= DRIZZLE_CON_SOCKET_TCP;
241
235
 
242
236
  if (host == NULL)
243
 
  {
244
237
    con->socket.tcp.host= NULL;
245
 
  }
246
238
  else
247
239
  {
248
240
    con->socket.tcp.host= con->socket.tcp.host_buffer;
255
247
 
256
248
const char *drizzle_con_user(const drizzle_con_st *con)
257
249
{
258
 
  if (con == NULL)
259
 
  {
260
 
    return NULL;
261
 
  }
262
 
 
263
250
  return con->user;
264
251
}
265
252
 
266
253
const char *drizzle_con_password(const drizzle_con_st *con)
267
254
{
268
 
  if (con == NULL)
269
 
  {
270
 
    return NULL;
271
 
  }
272
 
 
273
255
  return con->password;
274
256
}
275
257
 
276
 
void drizzle_con_set_auth(drizzle_con_st *con, const char *user, const char *password)
 
258
void drizzle_con_set_auth(drizzle_con_st *con, const char *user,
 
259
                          const char *password)
277
260
{
278
 
  if (con == NULL)
279
 
  {
280
 
    return;
281
 
  }
282
 
 
283
261
  if (user == NULL)
284
 
  {
285
262
    con->user[0]= 0;
286
 
  }
287
263
  else
288
264
  {
289
265
    strncpy(con->user, user, DRIZZLE_MAX_USER_SIZE);
291
267
  }
292
268
 
293
269
  if (password == NULL)
294
 
  {
295
270
    con->password[0]= 0;
296
 
  }
297
271
  else
298
272
  {
299
273
    strncpy(con->password, password, DRIZZLE_MAX_PASSWORD_SIZE);
301
275
  }
302
276
}
303
277
 
304
 
const char *drizzle_con_schema(const drizzle_con_st *con)
305
 
{
306
 
  if (con == NULL)
307
 
  {
308
 
    return NULL;
309
 
  }
310
 
 
311
 
  return con->schema;
312
 
}
313
 
 
314
278
const char *drizzle_con_db(const drizzle_con_st *con)
315
279
{
316
 
  return drizzle_con_schema(con);
 
280
  return con->db;
317
281
}
318
282
 
319
 
void drizzle_con_set_schema(drizzle_con_st *con, const char *schema)
 
283
void drizzle_con_set_db(drizzle_con_st *con, const char *db)
320
284
{
321
 
  if (con == NULL)
322
 
  {
323
 
    return;
324
 
  }
325
 
 
326
 
  if (schema == NULL)
327
 
  {
328
 
    con->schema[0]= 0;
329
 
  }
 
285
  if (db == NULL)
 
286
    con->db[0]= 0;
330
287
  else
331
288
  {
332
 
    strncpy(con->schema, schema, DRIZZLE_MAX_DB_SIZE);
333
 
    con->schema[DRIZZLE_MAX_DB_SIZE - 1]= 0;
 
289
    strncpy(con->db, db, DRIZZLE_MAX_DB_SIZE);
 
290
    con->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
334
291
  }
335
292
}
336
293
 
337
 
void drizzle_con_set_db(drizzle_con_st *con, const char *schema)
338
 
{
339
 
  drizzle_con_set_schema(con, schema);
340
 
}
341
 
 
342
294
void *drizzle_con_context(const drizzle_con_st *con)
343
295
{
344
 
  if (con == NULL)
345
 
  {
346
 
    return NULL;
347
 
  }
348
 
 
349
296
  return con->context;
350
297
}
351
298
 
352
299
void drizzle_con_set_context(drizzle_con_st *con, void *context)
353
300
{
354
 
  if (con == NULL)
355
 
  {
356
 
    return;
357
 
  }
358
 
 
359
301
  con->context= context;
360
302
}
361
303
 
362
304
void drizzle_con_set_context_free_fn(drizzle_con_st *con,
363
305
                                     drizzle_con_context_free_fn *function)
364
306
{
365
 
  if (con == NULL)
366
 
  {
367
 
    return;
368
 
  }
369
 
 
370
307
  con->context_free_fn= function;
371
308
}
372
309
 
373
310
uint8_t drizzle_con_protocol_version(const drizzle_con_st *con)
374
311
{
375
 
  if (con == NULL)
376
 
  {
377
 
    return 0;
378
 
  }
379
 
 
380
312
  return con->protocol_version;
381
313
}
382
314
 
383
315
const char *drizzle_con_server_version(const drizzle_con_st *con)
384
316
{
385
 
  if (con == NULL)
386
 
  {
387
 
    return NULL;
388
 
  }
389
 
 
390
317
  return con->server_version;
391
318
}
392
319
 
393
320
uint32_t drizzle_con_server_version_number(const drizzle_con_st *con)
394
321
{
395
 
  if (con == NULL or con->server_version)
396
 
  {
397
 
    return 0;
398
 
  }
 
322
  uint32_t major;
 
323
  uint32_t minor;
 
324
  uint32_t version;
 
325
  char *end;
399
326
 
400
327
  const char *current= con->server_version;
401
328
 
402
 
  char *end;
403
 
  uint32_t major= (uint32_t)strtoul(current, &end, 10);
404
 
  current= end + 1;
405
 
 
406
 
  uint32_t minor= (uint32_t)strtoul(current, &end, 10);
407
 
  current= end + 1;
408
 
 
409
 
  uint32_t version= (uint32_t)strtoul(current, &end, 10);
 
329
  major= (uint32_t)strtoul(current, &end, 10);
 
330
  current= end + 1;
 
331
  minor= (uint32_t)strtoul(current, &end, 10);
 
332
  current= end + 1;
 
333
  version= (uint32_t)strtoul(current, &end, 10);
410
334
 
411
335
  return (major * 10000) + (minor * 100) + version;
412
336
}
413
337
 
414
338
uint32_t drizzle_con_thread_id(const drizzle_con_st *con)
415
339
{
416
 
  if (con == NULL)
417
 
  {
418
 
    return 0;
419
 
  }
420
 
 
421
340
  return con->thread_id;
422
341
}
423
342
 
424
343
const uint8_t *drizzle_con_scramble(const drizzle_con_st *con)
425
344
{
426
 
  if (con == NULL)
427
 
  {
428
 
    return 0;
429
 
  }
430
 
 
431
345
  return con->scramble;
432
346
}
433
347
 
434
348
int drizzle_con_capabilities(const drizzle_con_st *con)
435
349
{
436
 
  if (con == NULL)
437
 
  {
438
 
    return 0;
439
 
  }
440
 
 
441
350
  return con->capabilities;
442
351
}
443
352
 
444
353
drizzle_charset_t drizzle_con_charset(const drizzle_con_st *con)
445
354
{
446
 
  if (con == NULL)
447
 
  {
448
 
    return drizzle_charset_t();
449
 
  }
450
 
 
451
355
  return con->charset;
452
356
}
453
357
 
454
358
drizzle_con_status_t drizzle_con_status(const drizzle_con_st *con)
455
359
{
456
 
  if (con == NULL)
457
 
  {
458
 
    return drizzle_con_status_t();
459
 
  }
460
 
 
461
360
  return con->status;
462
361
}
463
362
 
464
363
uint32_t drizzle_con_max_packet_size(const drizzle_con_st *con)
465
364
{
466
 
  if (con == NULL)
467
 
  {
468
 
    return 0;
469
 
  }
470
 
 
471
365
  return con->max_packet_size;
472
366
}
473
367
 
477
371
 
478
372
drizzle_return_t drizzle_con_connect(drizzle_con_st *con)
479
373
{
480
 
  if (con == NULL)
481
 
  {
482
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
483
 
  }
484
 
 
485
374
  if (con->options & DRIZZLE_CON_READY)
486
 
  {
487
375
    return DRIZZLE_RETURN_OK;
488
 
  }
489
376
 
490
377
  if (drizzle_state_none(con))
491
378
  {
539
426
                                        drizzle_result_st *result,
540
427
                                        drizzle_return_t *ret_ptr)
541
428
{
542
 
  if (con == NULL)
543
 
  {
544
 
    return NULL;
545
 
  }
546
 
 
547
429
  if (con->options & DRIZZLE_CON_MYSQL)
548
430
  {
549
431
    return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_SHUTDOWN,
555
437
}
556
438
 
557
439
drizzle_result_st *drizzle_shutdown(drizzle_con_st *con,
558
 
                                    drizzle_result_st *result, uint32_t,
 
440
                                    drizzle_result_st *result, uint32_t level,
559
441
                                    drizzle_return_t *ret_ptr)
560
442
{
 
443
  (void) level;
561
444
  return drizzle_con_shutdown(con, result, ret_ptr);
562
445
}
563
446
 
593
476
                                             size_t total,
594
477
                                             drizzle_return_t *ret_ptr)
595
478
{
596
 
  if (con == NULL)
597
 
  {
598
 
    return NULL;
599
 
  }
600
 
 
601
 
  drizzle_return_t unused;
602
 
  if (ret_ptr == NULL)
603
 
  {
604
 
    ret_ptr= &unused;
605
 
  }
606
 
 
607
 
  if ((con->options & DRIZZLE_CON_READY) == 0)
 
479
  drizzle_result_st *old_result;
 
480
 
 
481
  if (!(con->options & DRIZZLE_CON_READY))
608
482
  {
609
483
    if (con->options & DRIZZLE_CON_RAW_PACKET)
610
484
    {
611
 
      drizzle_set_error(con->drizzle, "drizzle_command_write", "connection not ready");
 
485
      drizzle_set_error(con->drizzle, "drizzle_command_write",
 
486
                        "connection not ready");
612
487
      *ret_ptr= DRIZZLE_RETURN_NOT_READY;
613
 
      return NULL;
 
488
      return result;
614
489
    }
615
490
 
616
491
    *ret_ptr= drizzle_con_connect(con);
617
492
    if (*ret_ptr != DRIZZLE_RETURN_OK)
618
 
    {
619
 
      return NULL;
620
 
    }
 
493
      return result;
621
494
  }
622
495
 
623
496
  if (drizzle_state_none(con))
624
497
  {
625
498
    if (con->options & (DRIZZLE_CON_RAW_PACKET | DRIZZLE_CON_NO_RESULT_READ))
626
 
    {
627
499
      con->result= NULL;
628
 
    }
629
500
    else
630
501
    {
631
 
      for (drizzle_result_st *old_result= con->result_list; old_result != NULL; old_result= old_result->next)
 
502
      for (old_result= con->result_list; old_result != NULL; old_result= old_result->next)
632
503
      {
633
504
        if (result == old_result)
634
505
        {
635
506
          drizzle_set_error(con->drizzle, "drizzle_command_write", "result struct already in use");
636
507
          *ret_ptr= DRIZZLE_RETURN_INTERNAL_ERROR;
637
 
          return NULL;
 
508
          return result;
638
509
        }
639
510
      }
640
511
 
641
 
      con->result= drizzle_result_create_with(con, result);
 
512
      con->result= drizzle_result_create(con, result);
642
513
      if (con->result == NULL)
643
514
      {
644
515
        *ret_ptr= DRIZZLE_RETURN_MEMORY;
662
533
 
663
534
  *ret_ptr= drizzle_state_loop(con);
664
535
  if (*ret_ptr == DRIZZLE_RETURN_PAUSE)
665
 
  {
666
536
    *ret_ptr= DRIZZLE_RETURN_OK;
667
 
  }
668
537
  else if (*ret_ptr != DRIZZLE_RETURN_OK &&
669
538
           *ret_ptr != DRIZZLE_RETURN_IO_WAIT &&
670
539
           *ret_ptr != DRIZZLE_RETURN_ERROR_CODE)
682
551
 
683
552
drizzle_return_t drizzle_con_listen(drizzle_con_st *con)
684
553
{
685
 
  if (con == NULL)
686
 
  {
687
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
688
 
  }
689
 
 
690
554
  if (con->options & DRIZZLE_CON_READY)
691
 
  {
692
555
    return DRIZZLE_RETURN_OK;
693
 
  }
694
556
 
695
557
  if (drizzle_state_none(con))
696
558
  {
703
565
 
704
566
int drizzle_con_backlog(const drizzle_con_st *con)
705
567
{
706
 
  if (con == NULL)
707
 
  {
708
 
    return 0;
709
 
  }
710
 
 
711
568
  return con->backlog;
712
569
}
713
570
 
714
571
void drizzle_con_set_backlog(drizzle_con_st *con, int backlog)
715
572
{
716
 
  if (con == NULL)
717
 
  {
718
 
    return;
719
 
  }
720
 
 
721
573
  con->backlog= backlog;
722
574
}
723
575
 
724
 
void drizzle_con_set_protocol_version(drizzle_con_st *con, uint8_t protocol_version)
 
576
void drizzle_con_set_protocol_version(drizzle_con_st *con,
 
577
                                      uint8_t protocol_version)
725
578
{
726
 
  if (con == NULL)
727
 
  {
728
 
    return;
729
 
  }
730
 
 
731
579
  con->protocol_version= protocol_version;
732
580
}
733
581
 
734
582
void drizzle_con_set_server_version(drizzle_con_st *con,
735
583
                                    const char *server_version)
736
584
{
737
 
  if (con == NULL)
738
 
  {
739
 
    return;
740
 
  }
741
 
 
742
585
  if (server_version == NULL)
743
 
  {
744
586
    con->server_version[0]= 0;
745
 
  }
746
587
  else
747
588
  {
748
589
    strncpy(con->server_version, server_version,
753
594
 
754
595
void drizzle_con_set_thread_id(drizzle_con_st *con, uint32_t thread_id)
755
596
{
756
 
  if (con == NULL)
757
 
  {
758
 
    return;
759
 
  }
760
 
 
761
597
  con->thread_id= thread_id;
762
598
}
763
599
 
764
600
void drizzle_con_set_scramble(drizzle_con_st *con, const uint8_t *scramble)
765
601
{
766
 
  if (con == NULL)
767
 
  {
768
 
    return;
769
 
  }
770
 
 
771
602
  if (scramble == NULL)
772
 
  {
773
603
    con->scramble= NULL;
774
 
  }
775
604
  else
776
605
  {
777
606
    con->scramble= con->scramble_buffer;
782
611
void drizzle_con_set_capabilities(drizzle_con_st *con,
783
612
                                  int capabilities)
784
613
{
785
 
  if (con == NULL)
786
 
  {
787
 
    return;
788
 
  }
789
 
 
790
614
  con->capabilities= capabilities;
791
615
}
792
616
 
793
617
void drizzle_con_set_charset(drizzle_con_st *con, drizzle_charset_t charset)
794
618
{
795
 
  if (con == NULL)
796
 
  {
797
 
    return;
798
 
  }
799
 
 
800
619
  con->charset= charset;
801
620
}
802
621
 
803
622
void drizzle_con_set_status(drizzle_con_st *con, drizzle_con_status_t status)
804
623
{
805
 
  if (con == NULL)
806
 
  {
807
 
    return;
808
 
  }
809
 
 
810
624
  con->status= status;
811
625
}
812
626
 
813
627
void drizzle_con_set_max_packet_size(drizzle_con_st *con,
814
628
                                     uint32_t max_packet_size)
815
629
{
816
 
  if (con == NULL)
817
 
  {
818
 
    return;
819
 
  }
820
 
 
821
630
  con->max_packet_size= max_packet_size;
822
631
}
823
632
 
824
633
void drizzle_con_copy_handshake(drizzle_con_st *con, drizzle_con_st *from)
825
634
{
826
 
  if (con == NULL)
827
 
  {
828
 
    return;
829
 
  }
830
 
 
831
635
  drizzle_con_set_auth(con, from->user, NULL);
832
636
  drizzle_con_set_scramble(con, from->scramble);
833
 
  drizzle_con_set_db(con, from->schema);
 
637
  drizzle_con_set_db(con, from->db);
834
638
  drizzle_con_set_protocol_version(con, from->protocol_version);
835
639
  drizzle_con_set_server_version(con, from->server_version);
836
640
  drizzle_con_set_thread_id(con, from->thread_id);
846
650
                               size_t *size, size_t *total,
847
651
                               drizzle_return_t *ret_ptr)
848
652
{
849
 
  if (con == NULL)
850
 
  {
851
 
    return NULL;
852
 
  }
853
 
 
854
 
  drizzle_return_t unused;
855
 
  if (ret_ptr == NULL)
856
 
  {
857
 
    ret_ptr= &unused;
858
 
  }
859
 
 
860
653
  if (drizzle_state_none(con))
861
654
  {
862
655
    con->packet_number= 0;
887
680
  size_t offset= 0;
888
681
  size_t size= 0;
889
682
 
890
 
  if (con == NULL)
891
 
  {
892
 
    return NULL;
893
 
  }
894
 
 
895
 
  drizzle_return_t unused;
896
 
  if (ret_ptr == NULL)
897
 
  {
898
 
    ret_ptr= &unused;
899
 
  }
900
 
 
901
 
  size_t total_unused;
902
 
  if (total == NULL)
903
 
  {
904
 
    total= &total_unused;
905
 
  }
906
 
 
907
683
  uint8_t *command_data=
908
684
    static_cast<uint8_t *>(drizzle_con_command_read(con, command, &offset,
909
685
                                                    &size, total, ret_ptr));
910
686
  if (*ret_ptr != DRIZZLE_RETURN_OK)
911
 
  {
912
687
    return NULL;
913
 
  }
914
688
 
915
689
  if (command_data == NULL)
916
690
  {
920
694
 
921
695
  if (con->command_buffer == NULL)
922
696
  {
923
 
    con->command_buffer= new (std::nothrow) uint8_t[(*total) + 1];
924
 
 
925
 
    if (con->command_buffer == NULL)
926
 
    {
927
 
      *total= 0;
928
 
      *ret_ptr= DRIZZLE_RETURN_MEMORY;
929
 
      return NULL;
930
 
    }
 
697
    con->command_buffer= new uint8_t[(*total) + 1];
931
698
  }
932
699
 
933
700
  memcpy(con->command_buffer + offset, command_data, size);
937
704
    command_data= (uint8_t *)drizzle_con_command_read(con, command, &offset,
938
705
                                                      &size, total, ret_ptr);
939
706
    if (*ret_ptr != DRIZZLE_RETURN_OK)
940
 
    {
941
707
      return NULL;
942
 
    }
943
708
 
944
709
    memcpy(con->command_buffer + offset, command_data, size);
945
710
  }
995
760
  struct addrinfo ai;
996
761
  int ret;
997
762
 
998
 
  if (con == NULL)
999
 
  {
1000
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1001
 
  }
1002
 
 
1003
763
  drizzle_log_debug(con->drizzle, "drizzle_state_addrinfo");
1004
764
 
1005
765
  switch (con->socket_type)
1014
774
    }
1015
775
 
1016
776
    if (tcp->port != 0)
1017
 
    {
1018
777
      snprintf(port, NI_MAXSERV, "%u", tcp->port);
1019
 
    }
1020
778
    else if (con->options & DRIZZLE_CON_MYSQL)
1021
 
    {
1022
779
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);
1023
 
    }
1024
780
    else
1025
 
    {
1026
781
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
1027
 
    }
1028
782
    port[NI_MAXSERV-1]= 0;
1029
783
 
1030
784
    memset(&ai, 0, sizeof(ai));
1068
822
 
1069
823
drizzle_return_t drizzle_state_connect(drizzle_con_st *con)
1070
824
{
1071
 
  if (con == NULL)
1072
 
  {
1073
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1074
 
  }
1075
825
  drizzle_log_debug(con->drizzle, "drizzle_state_connect");
1076
826
 
1077
827
  if (con->fd != -1)
1180
930
 
1181
931
drizzle_return_t drizzle_state_connecting(drizzle_con_st *con)
1182
932
{
1183
 
  if (con == NULL)
1184
 
  {
1185
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1186
 
  }
1187
933
  drizzle_log_debug(con->drizzle, "drizzle_state_connecting");
1188
934
 
1189
935
  while (1)
1206
952
    if (ret != DRIZZLE_RETURN_OK)
1207
953
      return ret;
1208
954
 
1209
 
    if (con->drizzle->options.is_non_blocking)
1210
 
    {
 
955
    if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1211
956
      return DRIZZLE_RETURN_IO_WAIT;
1212
 
    }
1213
957
 
1214
958
    ret= drizzle_con_wait(con->drizzle);
1215
959
    if (ret != DRIZZLE_RETURN_OK)
1216
 
    {
1217
960
      return ret;
1218
 
    }
1219
961
  }
1220
962
}
1221
963
 
1222
964
drizzle_return_t drizzle_state_read(drizzle_con_st *con)
1223
965
{
1224
 
  if (con == NULL)
1225
 
  {
1226
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1227
 
  }
 
966
  drizzle_return_t ret;
1228
967
 
1229
968
  drizzle_log_debug(con->drizzle, "drizzle_state_read");
1230
969
 
1237
976
  }
1238
977
 
1239
978
  if ((con->revents & POLLIN) == 0 &&
1240
 
      (con->drizzle->options.is_non_blocking))
 
979
      (con->drizzle->options & DRIZZLE_NON_BLOCKING))
1241
980
  {
1242
981
    /* non-blocking mode: return IO_WAIT instead of attempting to read. This
1243
982
     * avoids reading immediately after writing a command, which typically
1244
983
     * returns EAGAIN. This improves performance. */
1245
 
    drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
 
984
    ret= drizzle_con_set_events(con, POLLIN);
1246
985
    if (ret != DRIZZLE_RETURN_OK)
1247
 
    {
1248
986
      return ret;
1249
 
    }
1250
987
    return DRIZZLE_RETURN_IO_WAIT;
1251
988
  }
1252
989
 
1308
1045
      {
1309
1046
        /* clear the read ready flag */
1310
1047
        con->revents&= ~POLLIN;
1311
 
        drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
 
1048
        ret= drizzle_con_set_events(con, POLLIN);
1312
1049
        if (ret != DRIZZLE_RETURN_OK)
1313
 
        {
1314
1050
          return ret;
1315
 
        }
1316
1051
 
1317
 
        if (con->drizzle->options.is_non_blocking)
1318
 
        {
 
1052
        if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1319
1053
          return DRIZZLE_RETURN_IO_WAIT;
1320
 
        }
1321
1054
 
1322
1055
        ret= drizzle_con_wait(con->drizzle);
1323
1056
        if (ret != DRIZZLE_RETURN_OK)
1324
 
        {
1325
1057
          return ret;
1326
 
        }
1327
1058
 
1328
1059
        continue;
1329
1060
      }
1361
1092
 
1362
1093
drizzle_return_t drizzle_state_write(drizzle_con_st *con)
1363
1094
{
1364
 
  if (con == NULL)
1365
 
  {
1366
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1367
 
  }
 
1095
  drizzle_return_t ret;
1368
1096
 
1369
1097
  drizzle_log_debug(con->drizzle, "drizzle_state_write");
1370
1098
 
1422
1150
    {
1423
1151
      if (errno == EAGAIN)
1424
1152
      {
1425
 
        drizzle_return_t ret= drizzle_con_set_events(con, POLLOUT);
 
1153
        ret= drizzle_con_set_events(con, POLLOUT);
1426
1154
        if (ret != DRIZZLE_RETURN_OK)
1427
 
        {
1428
1155
          return ret;
1429
 
        }
1430
1156
 
1431
 
        if (con->drizzle->options.is_non_blocking)
1432
 
        {
 
1157
        if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1433
1158
          return DRIZZLE_RETURN_IO_WAIT;
1434
 
        }
1435
1159
 
1436
1160
        ret= drizzle_con_wait(con->drizzle);
1437
1161
        if (ret != DRIZZLE_RETURN_OK)
1438
 
        {
1439
1162
          return ret;
1440
 
        }
1441
1163
 
1442
1164
        continue;
1443
1165
      }
1444
1166
      else if (errno == EINTR)
1445
 
      {
1446
1167
        continue;
1447
 
      }
1448
1168
      else if (errno == EPIPE || errno == ECONNRESET)
1449
1169
      {
1450
1170
        drizzle_set_error(con->drizzle, "drizzle_state_write",
1478
1198
  int opt;
1479
1199
  drizzle_con_st *new_con;
1480
1200
 
1481
 
  if (con == NULL)
1482
 
  {
1483
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1484
 
  }
1485
 
 
1486
 
 
1487
1201
  for (; con->addrinfo_next != NULL;
1488
1202
       con->addrinfo_next= con->addrinfo_next->ai_next)
1489
1203
  {
1556
1270
    }
1557
1271
    else
1558
1272
    {
1559
 
      new_con= drizzle_con_clone(con->drizzle, con);
 
1273
      new_con= drizzle_con_clone(con->drizzle, NULL, con);
1560
1274
      if (new_con == NULL)
1561
1275
      {
1562
1276
        closesocket(fd);
1579
1293
 
1580
1294
  /* Report last socket() error if we couldn't find an address to bind. */
1581
1295
  if (con->fd == -1)
1582
 
  {
1583
1296
    return DRIZZLE_RETURN_ERRNO;
1584
 
  }
1585
1297
 
1586
1298
  drizzle_state_pop(con);
1587
1299
  return DRIZZLE_RETURN_OK;
1597
1309
  struct linger linger;
1598
1310
  struct timeval waittime;
1599
1311
 
1600
 
  if (con == NULL)
1601
 
  {
1602
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1603
 
  }
1604
 
 
1605
 
 
1606
1312
  ret= 1;
1607
1313
 
1608
1314
#ifdef _WIN32