« back to all changes in this revision
Viewing changes to libdrizzle/conn.cc
- browse files at revision 2472.1.2
- compare with another revision
- compare with revision 577
- download diff
- download tarball
- view history from revision 2472.1.2
- 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
added
removed
libdrizzle/conn.cc
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
Loggerhead is a web-based interface for Breezy
Version: 2.0.1