← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/conn.cc

  • Committer: Mark Atwood
  • Date: 2011-11-14 07:30:41 UTC
  • Revision ID: me@mark.atwood.name-20111114073041-mo2hgg8ouseo2kpu
release 2011.11.29

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/conn.cc
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
 
  }
 
479
  drizzle_result_st *old_result;
600
480
 
601
481
  drizzle_return_t unused;
602
482
  if (ret_ptr == NULL)
604
484
    ret_ptr= &unused;
605
485
  }
606
486
 
607
 
  if ((con->options & DRIZZLE_CON_READY) == 0)
 
487
  if (!(con->options & DRIZZLE_CON_READY))
608
488
  {
609
489
    if (con->options & DRIZZLE_CON_RAW_PACKET)
610
490
    {
611
 
      drizzle_set_error(con->drizzle, "drizzle_command_write", "connection not ready");
 
491
      drizzle_set_error(con->drizzle, "drizzle_command_write",
 
492
                        "connection not ready");
612
493
      *ret_ptr= DRIZZLE_RETURN_NOT_READY;
613
 
      return NULL;
 
494
      return result;
614
495
    }
615
496
 
616
497
    *ret_ptr= drizzle_con_connect(con);
617
498
    if (*ret_ptr != DRIZZLE_RETURN_OK)
618
499
    {
619
 
      return NULL;
 
500
      return result;
620
501
    }
621
502
  }
622
503
 
628
509
    }
629
510
    else
630
511
    {
631
 
      for (drizzle_result_st *old_result= con->result_list; old_result != NULL; old_result= old_result->next)
 
512
      for (old_result= con->result_list; old_result != NULL; old_result= old_result->next)
632
513
      {
633
514
        if (result == old_result)
634
515
        {
635
516
          drizzle_set_error(con->drizzle, "drizzle_command_write", "result struct already in use");
636
517
          *ret_ptr= DRIZZLE_RETURN_INTERNAL_ERROR;
637
 
          return NULL;
 
518
          return result;
638
519
        }
639
520
      }
640
521
 
641
 
      con->result= drizzle_result_create_with(con, result);
 
522
      con->result= drizzle_result_create(con, result);
642
523
      if (con->result == NULL)
643
524
      {
644
525
        *ret_ptr= DRIZZLE_RETURN_MEMORY;
662
543
 
663
544
  *ret_ptr= drizzle_state_loop(con);
664
545
  if (*ret_ptr == DRIZZLE_RETURN_PAUSE)
665
 
  {
666
546
    *ret_ptr= DRIZZLE_RETURN_OK;
667
 
  }
668
547
  else if (*ret_ptr != DRIZZLE_RETURN_OK &&
669
548
           *ret_ptr != DRIZZLE_RETURN_IO_WAIT &&
670
549
           *ret_ptr != DRIZZLE_RETURN_ERROR_CODE)
682
561
 
683
562
drizzle_return_t drizzle_con_listen(drizzle_con_st *con)
684
563
{
685
 
  if (con == NULL)
686
 
  {
687
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
688
 
  }
689
 
 
690
564
  if (con->options & DRIZZLE_CON_READY)
691
 
  {
692
565
    return DRIZZLE_RETURN_OK;
693
 
  }
694
566
 
695
567
  if (drizzle_state_none(con))
696
568
  {
703
575
 
704
576
int drizzle_con_backlog(const drizzle_con_st *con)
705
577
{
706
 
  if (con == NULL)
707
 
  {
708
 
    return 0;
709
 
  }
710
 
 
711
578
  return con->backlog;
712
579
}
713
580
 
714
581
void drizzle_con_set_backlog(drizzle_con_st *con, int backlog)
715
582
{
716
 
  if (con == NULL)
717
 
  {
718
 
    return;
719
 
  }
720
 
 
721
583
  con->backlog= backlog;
722
584
}
723
585
 
724
 
void drizzle_con_set_protocol_version(drizzle_con_st *con, uint8_t protocol_version)
 
586
void drizzle_con_set_protocol_version(drizzle_con_st *con,
 
587
                                      uint8_t protocol_version)
725
588
{
726
 
  if (con == NULL)
727
 
  {
728
 
    return;
729
 
  }
730
 
 
731
589
  con->protocol_version= protocol_version;
732
590
}
733
591
 
734
592
void drizzle_con_set_server_version(drizzle_con_st *con,
735
593
                                    const char *server_version)
736
594
{
737
 
  if (con == NULL)
738
 
  {
739
 
    return;
740
 
  }
741
 
 
742
595
  if (server_version == NULL)
743
 
  {
744
596
    con->server_version[0]= 0;
745
 
  }
746
597
  else
747
598
  {
748
599
    strncpy(con->server_version, server_version,
753
604
 
754
605
void drizzle_con_set_thread_id(drizzle_con_st *con, uint32_t thread_id)
755
606
{
756
 
  if (con == NULL)
757
 
  {
758
 
    return;
759
 
  }
760
 
 
761
607
  con->thread_id= thread_id;
762
608
}
763
609
 
764
610
void drizzle_con_set_scramble(drizzle_con_st *con, const uint8_t *scramble)
765
611
{
766
 
  if (con == NULL)
767
 
  {
768
 
    return;
769
 
  }
770
 
 
771
612
  if (scramble == NULL)
772
 
  {
773
613
    con->scramble= NULL;
774
 
  }
775
614
  else
776
615
  {
777
616
    con->scramble= con->scramble_buffer;
782
621
void drizzle_con_set_capabilities(drizzle_con_st *con,
783
622
                                  int capabilities)
784
623
{
785
 
  if (con == NULL)
786
 
  {
787
 
    return;
788
 
  }
789
 
 
790
624
  con->capabilities= capabilities;
791
625
}
792
626
 
793
627
void drizzle_con_set_charset(drizzle_con_st *con, drizzle_charset_t charset)
794
628
{
795
 
  if (con == NULL)
796
 
  {
797
 
    return;
798
 
  }
799
 
 
800
629
  con->charset= charset;
801
630
}
802
631
 
803
632
void drizzle_con_set_status(drizzle_con_st *con, drizzle_con_status_t status)
804
633
{
805
 
  if (con == NULL)
806
 
  {
807
 
    return;
808
 
  }
809
 
 
810
634
  con->status= status;
811
635
}
812
636
 
813
637
void drizzle_con_set_max_packet_size(drizzle_con_st *con,
814
638
                                     uint32_t max_packet_size)
815
639
{
816
 
  if (con == NULL)
817
 
  {
818
 
    return;
819
 
  }
820
 
 
821
640
  con->max_packet_size= max_packet_size;
822
641
}
823
642
 
824
643
void drizzle_con_copy_handshake(drizzle_con_st *con, drizzle_con_st *from)
825
644
{
826
 
  if (con == NULL)
827
 
  {
828
 
    return;
829
 
  }
830
 
 
831
645
  drizzle_con_set_auth(con, from->user, NULL);
832
646
  drizzle_con_set_scramble(con, from->scramble);
833
 
  drizzle_con_set_db(con, from->schema);
 
647
  drizzle_con_set_db(con, from->db);
834
648
  drizzle_con_set_protocol_version(con, from->protocol_version);
835
649
  drizzle_con_set_server_version(con, from->server_version);
836
650
  drizzle_con_set_thread_id(con, from->thread_id);
846
660
                               size_t *size, size_t *total,
847
661
                               drizzle_return_t *ret_ptr)
848
662
{
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
663
  if (drizzle_state_none(con))
861
664
  {
862
665
    con->packet_number= 0;
887
690
  size_t offset= 0;
888
691
  size_t size= 0;
889
692
 
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
693
  uint8_t *command_data=
908
694
    static_cast<uint8_t *>(drizzle_con_command_read(con, command, &offset,
909
695
                                                    &size, total, ret_ptr));
910
696
  if (*ret_ptr != DRIZZLE_RETURN_OK)
911
 
  {
912
697
    return NULL;
913
 
  }
914
698
 
915
699
  if (command_data == NULL)
916
700
  {
920
704
 
921
705
  if (con->command_buffer == NULL)
922
706
  {
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
 
    }
 
707
    con->command_buffer= new uint8_t[(*total) + 1];
931
708
  }
932
709
 
933
710
  memcpy(con->command_buffer + offset, command_data, size);
937
714
    command_data= (uint8_t *)drizzle_con_command_read(con, command, &offset,
938
715
                                                      &size, total, ret_ptr);
939
716
    if (*ret_ptr != DRIZZLE_RETURN_OK)
940
 
    {
941
717
      return NULL;
942
 
    }
943
718
 
944
719
    memcpy(con->command_buffer + offset, command_data, size);
945
720
  }
995
770
  struct addrinfo ai;
996
771
  int ret;
997
772
 
998
 
  if (con == NULL)
999
 
  {
1000
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1001
 
  }
1002
 
 
1003
773
  drizzle_log_debug(con->drizzle, "drizzle_state_addrinfo");
1004
774
 
1005
775
  switch (con->socket_type)
1014
784
    }
1015
785
 
1016
786
    if (tcp->port != 0)
1017
 
    {
1018
787
      snprintf(port, NI_MAXSERV, "%u", tcp->port);
1019
 
    }
1020
788
    else if (con->options & DRIZZLE_CON_MYSQL)
1021
 
    {
1022
789
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);
1023
 
    }
1024
790
    else
1025
 
    {
1026
791
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
1027
 
    }
1028
792
    port[NI_MAXSERV-1]= 0;
1029
793
 
1030
794
    memset(&ai, 0, sizeof(ai));
1068
832
 
1069
833
drizzle_return_t drizzle_state_connect(drizzle_con_st *con)
1070
834
{
1071
 
  if (con == NULL)
1072
 
  {
1073
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1074
 
  }
1075
835
  drizzle_log_debug(con->drizzle, "drizzle_state_connect");
1076
836
 
1077
837
  if (con->fd != -1)
1180
940
 
1181
941
drizzle_return_t drizzle_state_connecting(drizzle_con_st *con)
1182
942
{
1183
 
  if (con == NULL)
1184
 
  {
1185
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1186
 
  }
1187
943
  drizzle_log_debug(con->drizzle, "drizzle_state_connecting");
1188
944
 
1189
945
  while (1)
1206
962
    if (ret != DRIZZLE_RETURN_OK)
1207
963
      return ret;
1208
964
 
1209
 
    if (con->drizzle->options.is_non_blocking)
1210
 
    {
 
965
    if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1211
966
      return DRIZZLE_RETURN_IO_WAIT;
1212
 
    }
1213
967
 
1214
968
    ret= drizzle_con_wait(con->drizzle);
1215
969
    if (ret != DRIZZLE_RETURN_OK)
1216
 
    {
1217
970
      return ret;
1218
 
    }
1219
971
  }
1220
972
}
1221
973
 
1222
974
drizzle_return_t drizzle_state_read(drizzle_con_st *con)
1223
975
{
1224
 
  if (con == NULL)
1225
 
  {
1226
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1227
 
  }
 
976
  drizzle_return_t ret;
1228
977
 
1229
978
  drizzle_log_debug(con->drizzle, "drizzle_state_read");
1230
979
 
1237
986
  }
1238
987
 
1239
988
  if ((con->revents & POLLIN) == 0 &&
1240
 
      (con->drizzle->options.is_non_blocking))
 
989
      (con->drizzle->options & DRIZZLE_NON_BLOCKING))
1241
990
  {
1242
991
    /* non-blocking mode: return IO_WAIT instead of attempting to read. This
1243
992
     * avoids reading immediately after writing a command, which typically
1244
993
     * returns EAGAIN. This improves performance. */
1245
 
    drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
 
994
    ret= drizzle_con_set_events(con, POLLIN);
1246
995
    if (ret != DRIZZLE_RETURN_OK)
1247
 
    {
1248
996
      return ret;
1249
 
    }
1250
997
    return DRIZZLE_RETURN_IO_WAIT;
1251
998
  }
1252
999
 
1308
1055
      {
1309
1056
        /* clear the read ready flag */
1310
1057
        con->revents&= ~POLLIN;
1311
 
        drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
 
1058
        ret= drizzle_con_set_events(con, POLLIN);
1312
1059
        if (ret != DRIZZLE_RETURN_OK)
1313
 
        {
1314
1060
          return ret;
1315
 
        }
1316
1061
 
1317
 
        if (con->drizzle->options.is_non_blocking)
1318
 
        {
 
1062
        if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1319
1063
          return DRIZZLE_RETURN_IO_WAIT;
1320
 
        }
1321
1064
 
1322
1065
        ret= drizzle_con_wait(con->drizzle);
1323
1066
        if (ret != DRIZZLE_RETURN_OK)
1324
 
        {
1325
1067
          return ret;
1326
 
        }
1327
1068
 
1328
1069
        continue;
1329
1070
      }
1361
1102
 
1362
1103
drizzle_return_t drizzle_state_write(drizzle_con_st *con)
1363
1104
{
1364
 
  if (con == NULL)
1365
 
  {
1366
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1367
 
  }
 
1105
  drizzle_return_t ret;
1368
1106
 
1369
1107
  drizzle_log_debug(con->drizzle, "drizzle_state_write");
1370
1108
 
1422
1160
    {
1423
1161
      if (errno == EAGAIN)
1424
1162
      {
1425
 
        drizzle_return_t ret= drizzle_con_set_events(con, POLLOUT);
 
1163
        ret= drizzle_con_set_events(con, POLLOUT);
1426
1164
        if (ret != DRIZZLE_RETURN_OK)
1427
 
        {
1428
1165
          return ret;
1429
 
        }
1430
1166
 
1431
 
        if (con->drizzle->options.is_non_blocking)
1432
 
        {
 
1167
        if (con->drizzle->options & DRIZZLE_NON_BLOCKING)
1433
1168
          return DRIZZLE_RETURN_IO_WAIT;
1434
 
        }
1435
1169
 
1436
1170
        ret= drizzle_con_wait(con->drizzle);
1437
1171
        if (ret != DRIZZLE_RETURN_OK)
1438
 
        {
1439
1172
          return ret;
1440
 
        }
1441
1173
 
1442
1174
        continue;
1443
1175
      }
1444
1176
      else if (errno == EINTR)
1445
 
      {
1446
1177
        continue;
1447
 
      }
1448
1178
      else if (errno == EPIPE || errno == ECONNRESET)
1449
1179
      {
1450
1180
        drizzle_set_error(con->drizzle, "drizzle_state_write",
1478
1208
  int opt;
1479
1209
  drizzle_con_st *new_con;
1480
1210
 
1481
 
  if (con == NULL)
1482
 
  {
1483
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1484
 
  }
1485
 
 
1486
 
 
1487
1211
  for (; con->addrinfo_next != NULL;
1488
1212
       con->addrinfo_next= con->addrinfo_next->ai_next)
1489
1213
  {
1556
1280
    }
1557
1281
    else
1558
1282
    {
1559
 
      new_con= drizzle_con_clone(con->drizzle, con);
 
1283
      new_con= drizzle_con_clone(con->drizzle, NULL, con);
1560
1284
      if (new_con == NULL)
1561
1285
      {
1562
1286
        closesocket(fd);
1579
1303
 
1580
1304
  /* Report last socket() error if we couldn't find an address to bind. */
1581
1305
  if (con->fd == -1)
1582
 
  {
1583
1306
    return DRIZZLE_RETURN_ERRNO;
1584
 
  }
1585
1307
 
1586
1308
  drizzle_state_pop(con);
1587
1309
  return DRIZZLE_RETURN_OK;
1597
1319
  struct linger linger;
1598
1320
  struct timeval waittime;
1599
1321
 
1600
 
  if (con == NULL)
1601
 
  {
1602
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1603
 
  }
1604
 
 
1605
 
 
1606
1322
  ret= 1;
1607
1323
 
1608
1324
#ifdef _WIN32