~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/conn.cc

  • Committer: Brian Aker
  • Date: 2011-12-19 16:28:27 UTC
  • mto: (2478.1.1 drizzle-build)
  • mto: This revision was merged to the branch mainline in revision 2478.
  • Revision ID: brian@tangent.org-20111219162827-bfwc9zzfk10omyil
Null safety fix for libdrizzle

Show diffs side-by-side

added added

removed removed

Lines of Context:
66
66
 
67
67
int drizzle_con_fd(const drizzle_con_st *con)
68
68
{
 
69
  if (con == NULL)
 
70
  {
 
71
    return -1;
 
72
  }
 
73
 
69
74
  return con->fd;
70
75
}
71
76
 
72
77
drizzle_return_t drizzle_con_set_fd(drizzle_con_st *con, int fd)
73
78
{
74
79
  drizzle_return_t ret;
 
80
  if (con == NULL)
 
81
  {
 
82
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
83
  }
75
84
 
76
85
  con->fd= fd;
77
86
 
84
93
 
85
94
void drizzle_con_close(drizzle_con_st *con)
86
95
{
 
96
  if (con == NULL)
 
97
  {
 
98
    return;
 
99
  }
 
100
 
87
101
  if (con->fd == -1)
 
102
  {
88
103
    return;
 
104
  }
89
105
 
90
106
  (void)closesocket(con->fd);
91
107
  con->fd= -1;
105
121
  drizzle_return_t ret;
106
122
 
107
123
  if ((con->events | events) == con->events)
 
124
  {
108
125
    return DRIZZLE_RETURN_OK;
 
126
  }
109
127
 
110
128
  con->events|= events;
111
129
 
126
144
drizzle_return_t drizzle_con_set_revents(drizzle_con_st *con, short revents)
127
145
{
128
146
  drizzle_return_t ret;
 
147
  if (con == NULL)
 
148
  {
 
149
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
150
  }
129
151
 
130
152
  if (revents != 0)
131
153
    con->options|= DRIZZLE_CON_IO_READY;
155
177
 
156
178
drizzle_st *drizzle_con_drizzle(const drizzle_con_st *con)
157
179
{
 
180
  if (con == NULL)
 
181
  {
 
182
    return NULL;
 
183
  }
158
184
  return con->drizzle;
159
185
}
160
186
 
161
187
const char *drizzle_con_error(const drizzle_con_st *con)
162
188
{
 
189
  if (con == NULL)
 
190
  {
 
191
    return NULL;
 
192
  }
 
193
 
163
194
  return drizzle_error(con->drizzle);
164
195
}
165
196
 
166
197
int drizzle_con_errno(const drizzle_con_st *con)
167
198
{
 
199
  if (con == NULL)
 
200
  {
 
201
    return 0;
 
202
  }
 
203
 
168
204
  return drizzle_errno(con->drizzle);
169
205
}
170
206
 
171
207
uint16_t drizzle_con_error_code(const drizzle_con_st *con)
172
208
{
 
209
  if (con == NULL)
 
210
  {
 
211
    return 0;
 
212
  }
 
213
 
173
214
  return drizzle_error_code(con->drizzle);
174
215
}
175
216
 
176
217
const char *drizzle_con_sqlstate(const drizzle_con_st *con)
177
218
{
 
219
  if (con == NULL)
 
220
  {
 
221
    return NULL;
 
222
  }
 
223
 
178
224
  return drizzle_sqlstate(con->drizzle);
179
225
}
180
226
 
181
227
drizzle_con_options_t drizzle_con_options(const drizzle_con_st *con)
182
228
{
 
229
  if (con == NULL)
 
230
  {
 
231
    return drizzle_con_options_t();
 
232
  }
 
233
 
183
234
  return drizzle_con_options_t(con->options);
184
235
}
185
236
 
186
237
void drizzle_con_set_options(drizzle_con_st *con,
187
238
                             drizzle_con_options_t options)
188
239
{
 
240
  if (con == NULL)
 
241
  {
 
242
    return;
 
243
  }
 
244
 
189
245
  con->options= options;
190
246
}
191
247
 
192
248
void drizzle_con_add_options(drizzle_con_st *con,
193
249
                             drizzle_con_options_t options)
194
250
{
 
251
  if (con == NULL)
 
252
  {
 
253
    return;
 
254
  }
 
255
 
195
256
  con->options|= options;
196
257
 
197
258
  /* If asking for the experimental Drizzle protocol, clean the MySQL flag. */
204
265
void drizzle_con_remove_options(drizzle_con_st *con,
205
266
                                drizzle_con_options_t options)
206
267
{
 
268
  if (con == NULL)
 
269
  {
 
270
    return;
 
271
  }
 
272
 
207
273
  con->options&= ~options;
208
274
}
209
275
 
210
276
const char *drizzle_con_host(const drizzle_con_st *con)
211
277
{
 
278
  if (con == NULL)
 
279
  {
 
280
    return NULL;
 
281
  }
 
282
 
212
283
  if (con->socket_type == DRIZZLE_CON_SOCKET_TCP)
213
284
  {
214
285
    if (con->socket.tcp.host == NULL && !(con->options & DRIZZLE_CON_LISTEN))
222
293
 
223
294
in_port_t drizzle_con_port(const drizzle_con_st *con)
224
295
{
225
 
  if (con->socket_type == DRIZZLE_CON_SOCKET_TCP)
 
296
  if (con and con->socket_type == DRIZZLE_CON_SOCKET_TCP)
226
297
  {
227
298
    if (con->socket.tcp.port != 0)
 
299
    {
228
300
      return con->socket.tcp.port;
 
301
    }
229
302
 
230
303
    if (con->options & DRIZZLE_CON_MYSQL)
 
304
    {
231
305
      return DRIZZLE_DEFAULT_TCP_PORT_MYSQL;
 
306
    }
232
307
 
233
308
    return DRIZZLE_DEFAULT_TCP_PORT;
234
309
  }
235
310
 
236
 
  return 0;
 
311
  return in_port_t(0);
237
312
}
238
313
 
239
314
void drizzle_con_set_tcp(drizzle_con_st *con, const char *host, in_port_t port)
240
315
{
 
316
  if (con == NULL)
 
317
  {
 
318
    return;
 
319
  }
 
320
 
241
321
  drizzle_con_reset_addrinfo(con);
242
322
 
243
323
  con->socket_type= DRIZZLE_CON_SOCKET_TCP;
244
324
 
245
325
  if (host == NULL)
 
326
  {
246
327
    con->socket.tcp.host= NULL;
 
328
  }
247
329
  else
248
330
  {
249
331
    con->socket.tcp.host= con->socket.tcp.host_buffer;
256
338
 
257
339
const char *drizzle_con_user(const drizzle_con_st *con)
258
340
{
 
341
  if (con == NULL)
 
342
  {
 
343
    return NULL;
 
344
  }
 
345
 
259
346
  return con->user;
260
347
}
261
348
 
262
349
const char *drizzle_con_password(const drizzle_con_st *con)
263
350
{
 
351
  if (con == NULL)
 
352
  {
 
353
    return NULL;
 
354
  }
 
355
 
264
356
  return con->password;
265
357
}
266
358
 
267
359
void drizzle_con_set_auth(drizzle_con_st *con, const char *user,
268
360
                          const char *password)
269
361
{
 
362
  if (con == NULL)
 
363
  {
 
364
    return;
 
365
  }
 
366
 
270
367
  if (user == NULL)
 
368
  {
271
369
    con->user[0]= 0;
 
370
  }
272
371
  else
273
372
  {
274
373
    strncpy(con->user, user, DRIZZLE_MAX_USER_SIZE);
276
375
  }
277
376
 
278
377
  if (password == NULL)
 
378
  {
279
379
    con->password[0]= 0;
 
380
  }
280
381
  else
281
382
  {
282
383
    strncpy(con->password, password, DRIZZLE_MAX_PASSWORD_SIZE);
286
387
 
287
388
const char *drizzle_con_db(const drizzle_con_st *con)
288
389
{
 
390
  if (con == NULL)
 
391
  {
 
392
    return NULL;
 
393
  }
 
394
 
289
395
  return con->db;
290
396
}
291
397
 
292
398
void drizzle_con_set_db(drizzle_con_st *con, const char *db)
293
399
{
 
400
  if (con == NULL)
 
401
  {
 
402
    return;
 
403
  }
 
404
 
294
405
  if (db == NULL)
 
406
  {
295
407
    con->db[0]= 0;
 
408
  }
296
409
  else
297
410
  {
298
411
    strncpy(con->db, db, DRIZZLE_MAX_DB_SIZE);
302
415
 
303
416
void *drizzle_con_context(const drizzle_con_st *con)
304
417
{
 
418
  if (con == NULL)
 
419
  {
 
420
    return NULL;
 
421
  }
 
422
 
305
423
  return con->context;
306
424
}
307
425
 
308
426
void drizzle_con_set_context(drizzle_con_st *con, void *context)
309
427
{
 
428
  if (con == NULL)
 
429
  {
 
430
    return;
 
431
  }
 
432
 
310
433
  con->context= context;
311
434
}
312
435
 
313
436
void drizzle_con_set_context_free_fn(drizzle_con_st *con,
314
437
                                     drizzle_con_context_free_fn *function)
315
438
{
 
439
  if (con == NULL)
 
440
  {
 
441
    return;
 
442
  }
 
443
 
316
444
  con->context_free_fn= function;
317
445
}
318
446
 
319
447
uint8_t drizzle_con_protocol_version(const drizzle_con_st *con)
320
448
{
 
449
  if (con == NULL)
 
450
  {
 
451
    return 0;
 
452
  }
 
453
 
321
454
  return con->protocol_version;
322
455
}
323
456
 
324
457
const char *drizzle_con_server_version(const drizzle_con_st *con)
325
458
{
 
459
  if (con == NULL)
 
460
  {
 
461
    return NULL;
 
462
  }
 
463
 
326
464
  return con->server_version;
327
465
}
328
466
 
329
467
uint32_t drizzle_con_server_version_number(const drizzle_con_st *con)
330
468
{
331
 
  uint32_t major;
332
 
  uint32_t minor;
333
 
  uint32_t version;
334
 
  const char *current;
335
 
  char *end;
336
 
 
337
 
  current= con->server_version;
338
 
 
339
 
  major= (uint32_t)strtoul(current, &end, 10);
340
 
  current= end + 1;
341
 
  minor= (uint32_t)strtoul(current, &end, 10);
342
 
  current= end + 1;
343
 
  version= (uint32_t)strtoul(current, &end, 10);
344
 
 
345
 
  return (major * 10000) + (minor * 100) + version;
 
469
  if (con)
 
470
  {
 
471
    const char *current= con->server_version;
 
472
    char *end;
 
473
 
 
474
    uint32_t major= (uint32_t)strtoul(current, &end, 10);
 
475
    current= end +1;
 
476
    uint32_t minor= (uint32_t)strtoul(current, &end, 10);
 
477
    current= end +1;
 
478
    uint32_t version= (uint32_t)strtoul(current, &end, 10);
 
479
 
 
480
    return (major * 10000) +(minor * 100) +version;
 
481
  }
 
482
 
 
483
  return 0;
346
484
}
347
485
 
348
486
uint32_t drizzle_con_thread_id(const drizzle_con_st *con)
349
487
{
 
488
  if (con == NULL)
 
489
  {
 
490
    return 0;
 
491
  }
 
492
 
350
493
  return con->thread_id;
351
494
}
352
495
 
353
496
const uint8_t *drizzle_con_scramble(const drizzle_con_st *con)
354
497
{
 
498
  if (con == NULL)
 
499
  {
 
500
    return NULL;
 
501
  }
 
502
 
355
503
  return con->scramble;
356
504
}
357
505
 
358
506
drizzle_capabilities_t drizzle_con_capabilities(const drizzle_con_st *con)
359
507
{
 
508
  if (con == NULL)
 
509
  {
 
510
    return drizzle_capabilities_t();
 
511
  }
 
512
 
360
513
  return drizzle_capabilities_t(con->capabilities);
361
514
}
362
515
 
363
516
drizzle_charset_t drizzle_con_charset(const drizzle_con_st *con)
364
517
{
 
518
  if (con == NULL)
 
519
  {
 
520
    return drizzle_charset_t();
 
521
  }
 
522
 
365
523
  return con->charset;
366
524
}
367
525
 
368
526
drizzle_con_status_t drizzle_con_status(const drizzle_con_st *con)
369
527
{
 
528
  if (con == NULL)
 
529
  {
 
530
    return drizzle_con_status_t();
 
531
  }
 
532
 
370
533
  return con->status;
371
534
}
372
535
 
373
536
uint32_t drizzle_con_max_packet_size(const drizzle_con_st *con)
374
537
{
 
538
  if (con == NULL)
 
539
  {
 
540
    return 0;
 
541
  }
 
542
 
375
543
  return con->max_packet_size;
376
544
}
377
545
 
381
549
 
382
550
drizzle_return_t drizzle_con_connect(drizzle_con_st *con)
383
551
{
 
552
  if (con == NULL)
 
553
  {
 
554
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
555
  }
 
556
 
384
557
  if (con->options & DRIZZLE_CON_READY)
 
558
  {
385
559
    return DRIZZLE_RETURN_OK;
 
560
  }
386
561
 
387
562
  if (drizzle_state_none(con))
388
563
  {
436
611
                                        drizzle_result_st *result,
437
612
                                        drizzle_return_t *ret_ptr)
438
613
{
439
 
  if (con->options & DRIZZLE_CON_MYSQL)
 
614
  drizzle_return_t unused;
 
615
  if (ret_ptr == NULL)
 
616
  {
 
617
    ret_ptr= &unused;
 
618
  }
 
619
 
 
620
  if (con and con->options & DRIZZLE_CON_MYSQL)
440
621
  {
441
622
    return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_SHUTDOWN,
442
623
                                     "0", 1, 1, ret_ptr);
447
628
}
448
629
 
449
630
drizzle_result_st *drizzle_shutdown(drizzle_con_st *con,
450
 
                                    drizzle_result_st *result, uint32_t level,
 
631
                                    drizzle_result_st *result, uint32_t, // level is unused
451
632
                                    drizzle_return_t *ret_ptr)
452
633
{
453
 
  (void) level;
454
634
  return drizzle_con_shutdown(con, result, ret_ptr);
455
635
}
456
636
 
459
639
                                uint32_t query_id,
460
640
                                drizzle_return_t *ret_ptr)
461
641
{
 
642
  drizzle_return_t unused;
 
643
  if (ret_ptr == NULL)
 
644
  {
 
645
    ret_ptr= &unused;
 
646
  }
 
647
 
462
648
  uint32_t sent= htonl(query_id);
463
649
  return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_PROCESS_KILL,
464
650
                                   &sent, sizeof(uint32_t), sizeof(uint32_t), ret_ptr);
486
672
                                             size_t total,
487
673
                                             drizzle_return_t *ret_ptr)
488
674
{
 
675
  drizzle_return_t unused;
 
676
  if (ret_ptr == NULL)
 
677
  {
 
678
    ret_ptr= &unused;
 
679
  }
 
680
 
 
681
  if (con == NULL)
 
682
  {
 
683
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
684
    return NULL;
 
685
  }
 
686
 
489
687
  drizzle_result_st *old_result;
490
688
 
491
 
  drizzle_return_t unused;
492
 
  if (ret_ptr == NULL)
493
 
  {
494
 
    ret_ptr= &unused;
495
 
  }
496
 
 
497
689
  if (!(con->options & DRIZZLE_CON_READY))
498
690
  {
499
691
    if (con->options & DRIZZLE_CON_RAW_PACKET)
567
759
 
568
760
drizzle_return_t drizzle_con_listen(drizzle_con_st *con)
569
761
{
 
762
  if (con == NULL)
 
763
  {
 
764
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
765
  }
 
766
 
570
767
  if (con->options & DRIZZLE_CON_READY)
 
768
  {
571
769
    return DRIZZLE_RETURN_OK;
 
770
  }
572
771
 
573
772
  if (drizzle_state_none(con))
574
773
  {
581
780
 
582
781
int drizzle_con_backlog(const drizzle_con_st *con)
583
782
{
 
783
  if (con == NULL)
 
784
  {
 
785
    return 0;
 
786
  }
 
787
 
584
788
  return con->backlog;
585
789
}
586
790
 
587
791
void drizzle_con_set_backlog(drizzle_con_st *con, int backlog)
588
792
{
 
793
  if (con == NULL)
 
794
  {
 
795
    return;
 
796
  }
 
797
 
589
798
  con->backlog= backlog;
590
799
}
591
800
 
592
801
void drizzle_con_set_protocol_version(drizzle_con_st *con,
593
802
                                      uint8_t protocol_version)
594
803
{
 
804
  if (con == NULL)
 
805
  {
 
806
    return;
 
807
  }
 
808
 
595
809
  con->protocol_version= protocol_version;
596
810
}
597
811
 
598
812
void drizzle_con_set_server_version(drizzle_con_st *con,
599
813
                                    const char *server_version)
600
814
{
 
815
  if (con == NULL)
 
816
  {
 
817
    return;
 
818
  }
 
819
 
601
820
  if (server_version == NULL)
 
821
  {
602
822
    con->server_version[0]= 0;
 
823
  }
603
824
  else
604
825
  {
605
826
    strncpy(con->server_version, server_version,
610
831
 
611
832
void drizzle_con_set_thread_id(drizzle_con_st *con, uint32_t thread_id)
612
833
{
 
834
  if (con == NULL)
 
835
  {
 
836
    return;
 
837
  }
 
838
 
613
839
  con->thread_id= thread_id;
614
840
}
615
841
 
616
842
void drizzle_con_set_scramble(drizzle_con_st *con, const uint8_t *scramble)
617
843
{
 
844
  if (con == NULL)
 
845
  {
 
846
    return;
 
847
  }
 
848
 
618
849
  if (scramble == NULL)
 
850
  {
619
851
    con->scramble= NULL;
 
852
  }
620
853
  else
621
854
  {
622
855
    con->scramble= con->scramble_buffer;
627
860
void drizzle_con_set_capabilities(drizzle_con_st *con,
628
861
                                  drizzle_capabilities_t capabilities)
629
862
{
 
863
  if (con == NULL)
 
864
  {
 
865
    return;
 
866
  }
 
867
 
630
868
  con->capabilities= capabilities;
631
869
}
632
870
 
633
871
void drizzle_con_set_charset(drizzle_con_st *con, drizzle_charset_t charset)
634
872
{
 
873
  if (con == NULL)
 
874
  {
 
875
    return;
 
876
  }
 
877
 
635
878
  con->charset= charset;
636
879
}
637
880
 
638
881
void drizzle_con_set_status(drizzle_con_st *con, drizzle_con_status_t status)
639
882
{
 
883
  if (con == NULL)
 
884
  {
 
885
    return;
 
886
  }
 
887
 
640
888
  con->status= status;
641
889
}
642
890
 
643
891
void drizzle_con_set_max_packet_size(drizzle_con_st *con,
644
892
                                     uint32_t max_packet_size)
645
893
{
 
894
  if (con == NULL)
 
895
  {
 
896
    return;
 
897
  }
 
898
 
646
899
  con->max_packet_size= max_packet_size;
647
900
}
648
901
 
666
919
                               size_t *size, size_t *total,
667
920
                               drizzle_return_t *ret_ptr)
668
921
{
 
922
  drizzle_return_t unused_ret;
 
923
  if (ret_ptr == NULL)
 
924
  {
 
925
    ret_ptr= &unused_ret;
 
926
  }
 
927
 
 
928
  if (con == NULL)
 
929
  {
 
930
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
931
    return NULL;
 
932
  }
 
933
 
669
934
  if (drizzle_state_none(con))
670
935
  {
671
936
    con->packet_number= 0;
676
941
    drizzle_state_push(con, drizzle_state_packet_read);
677
942
  }
678
943
 
679
 
  *offset= con->command_offset;
 
944
  if (offset)
 
945
  {
 
946
    *offset= con->command_offset;
 
947
  }
680
948
 
681
949
  *ret_ptr= drizzle_state_loop(con);
682
950
  if (*ret_ptr == DRIZZLE_RETURN_PAUSE)
 
951
  {
683
952
    *ret_ptr= DRIZZLE_RETURN_OK;
684
 
 
685
 
  *command= con->command;
686
 
  *size= con->command_size;
687
 
  *total= con->command_total;
 
953
  }
 
954
 
 
955
  if (command)
 
956
  {
 
957
    *command= con->command;
 
958
  }
 
959
 
 
960
  if (size)
 
961
  {
 
962
    *size= con->command_size;
 
963
  }
 
964
 
 
965
  if (total)
 
966
  {
 
967
    *total= con->command_total;
 
968
  }
688
969
 
689
970
  return con->command_data;
690
971
}
696
977
  size_t offset= 0;
697
978
  size_t size= 0;
698
979
 
 
980
  drizzle_return_t unused_ret;
 
981
  if (ret_ptr == NULL)
 
982
  {
 
983
    ret_ptr= &unused_ret;
 
984
  }
 
985
 
 
986
  size_t unused_total;
 
987
  if (total == NULL)
 
988
  {
 
989
    total= &unused_total;
 
990
  }
 
991
 
 
992
  if (con == NULL)
 
993
  {
 
994
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
995
    return NULL;
 
996
  }
 
997
 
699
998
  char *command_data= (char *)drizzle_con_command_read(con, command, &offset, &size, total, ret_ptr);
700
999
  if (*ret_ptr != DRIZZLE_RETURN_OK)
 
1000
  {
701
1001
    return NULL;
 
1002
  }
702
1003
 
703
1004
  if (command_data == NULL)
704
1005
  {
723
1024
  {
724
1025
    command_data= (char *)drizzle_con_command_read(con, command, &offset, &size, total, ret_ptr);
725
1026
    if (*ret_ptr != DRIZZLE_RETURN_OK)
 
1027
    {
726
1028
      return NULL;
 
1029
    }
727
1030
 
728
1031
    memcpy(con->command_buffer + offset, command_data, size);
729
1032
  }
741
1044
 
742
1045
void drizzle_con_reset_addrinfo(drizzle_con_st *con)
743
1046
{
 
1047
  if (con == NULL)
 
1048
  {
 
1049
    return;
 
1050
  }
 
1051
 
744
1052
  switch (con->socket_type)
745
1053
  {
746
1054
  case DRIZZLE_CON_SOCKET_TCP:
774
1082
  struct addrinfo ai;
775
1083
  int ret;
776
1084
 
 
1085
  if (con == NULL)
 
1086
  {
 
1087
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1088
  }
 
1089
 
777
1090
  drizzle_log_debug(con->drizzle, "drizzle_state_addrinfo");
778
1091
 
779
1092
  switch (con->socket_type)
788
1101
    }
789
1102
 
790
1103
    if (tcp->port != 0)
 
1104
    {
791
1105
      snprintf(port, NI_MAXSERV, "%u", tcp->port);
 
1106
    }
792
1107
    else if (con->options & DRIZZLE_CON_MYSQL)
 
1108
    {
793
1109
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);
 
1110
    }
794
1111
    else
 
1112
    {
795
1113
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
 
1114
    }
796
1115
    port[NI_MAXSERV-1]= 0;
797
1116
 
798
1117
    memset(&ai, 0, sizeof(struct addrinfo));
842
1161
  int ret;
843
1162
  drizzle_return_t dret;
844
1163
 
 
1164
  if (con == NULL)
 
1165
  {
 
1166
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1167
  }
 
1168
 
845
1169
  drizzle_log_debug(con->drizzle, "drizzle_state_connect");
846
1170
 
847
1171
  if (con->fd != -1)
946
1270
  }
947
1271
 
948
1272
  drizzle_state_pop(con);
 
1273
 
949
1274
  return DRIZZLE_RETURN_OK;
950
1275
}
951
1276
 
953
1278
{
954
1279
  drizzle_return_t ret;
955
1280
 
 
1281
  if (con == NULL)
 
1282
  {
 
1283
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1284
  }
 
1285
 
956
1286
  drizzle_log_debug(con->drizzle, "drizzle_state_connecting");
957
1287
 
958
1288
  while (1)
980
1310
 
981
1311
    ret= drizzle_con_wait(con->drizzle);
982
1312
    if (ret != DRIZZLE_RETURN_OK)
 
1313
    {
983
1314
      return ret;
 
1315
    }
984
1316
  }
985
1317
}
986
1318
 
989
1321
  drizzle_return_t ret;
990
1322
  ssize_t read_size;
991
1323
 
 
1324
  if (con == NULL)
 
1325
  {
 
1326
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1327
  }
 
1328
 
992
1329
  drizzle_log_debug(con->drizzle, "drizzle_state_read");
993
1330
 
994
1331
  if (con->buffer_size == 0)
1110
1447
  }
1111
1448
 
1112
1449
  drizzle_state_pop(con);
 
1450
 
1113
1451
  return DRIZZLE_RETURN_OK;
1114
1452
}
1115
1453
 
1118
1456
  drizzle_return_t ret;
1119
1457
  ssize_t write_size;
1120
1458
 
 
1459
  if (con == NULL)
 
1460
  {
 
1461
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1462
  }
 
1463
 
1121
1464
  drizzle_log_debug(con->drizzle, "drizzle_state_write");
1122
1465
 
1123
1466
  while (con->buffer_size != 0)
1211
1554
  con->buffer_ptr= con->buffer;
1212
1555
 
1213
1556
  drizzle_state_pop(con);
 
1557
 
1214
1558
  return DRIZZLE_RETURN_OK;
1215
1559
}
1216
1560
 
1222
1566
  int opt;
1223
1567
  drizzle_con_st *new_con;
1224
1568
 
 
1569
  if (con == NULL)
 
1570
  {
 
1571
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1572
  }
 
1573
 
1225
1574
  for (; con->addrinfo_next != NULL;
1226
1575
       con->addrinfo_next= con->addrinfo_next->ai_next)
1227
1576
  {
1316
1665
 
1317
1666
  /* Report last socket() error if we couldn't find an address to bind. */
1318
1667
  if (con->fd == -1)
 
1668
  {
1319
1669
    return DRIZZLE_RETURN_ERRNO;
 
1670
  }
1320
1671
 
1321
1672
  drizzle_state_pop(con);
 
1673
 
1322
1674
  return DRIZZLE_RETURN_OK;
1323
1675
}
1324
1676
 
1332
1684
  struct linger linger;
1333
1685
  struct timeval waittime;
1334
1686
 
 
1687
  assert(con);
 
1688
 
1335
1689
  ret= 1;
1336
1690
 
1337
1691
#ifdef _WIN32