← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/drizzle.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:
libdrizzle/drizzle.cc
80
80
const char *drizzle_verbose_name(drizzle_verbose_t verbose)
81
81
{
82
82
  if (verbose >= DRIZZLE_VERBOSE_MAX)
 
83
  {
83
84
    return "UNKNOWN";
 
85
  }
84
86
 
85
87
  return _verbose_name[verbose];
86
88
}
104
106
  {
105
107
    drizzle= new (std::nothrow) drizzle_st;
106
108
    if (drizzle == NULL)
 
109
    {
107
110
      return NULL;
 
111
    }
108
112
 
109
113
    drizzle->options= DRIZZLE_ALLOCATED;
110
114
  }
111
115
  else
 
116
  {
112
117
    drizzle->options= DRIZZLE_NONE;
 
118
  }
113
119
 
114
120
  /* @todo remove this default free flag with new API. */
115
121
  drizzle->options|= DRIZZLE_FREE_OBJECTS;
140
146
 
141
147
drizzle_st *drizzle_clone(drizzle_st *drizzle, const drizzle_st *from)
142
148
{
143
 
  drizzle_con_st *con;
144
 
 
145
149
  drizzle= drizzle_create(drizzle);
146
150
  if (drizzle == NULL)
 
151
  {
147
152
    return NULL;
 
153
  }
148
154
 
149
155
  drizzle->options|= (from->options & int(~DRIZZLE_ALLOCATED));
150
156
 
151
 
  for (con= from->con_list; con != NULL; con= con->next)
 
157
  for (drizzle_con_st *con= from->con_list; con != NULL; con= con->next)
152
158
  {
153
159
    if (drizzle_con_clone(drizzle, NULL, con) == NULL)
154
160
    {
162
168
 
163
169
void drizzle_free(drizzle_st *drizzle)
164
170
{
 
171
  if (drizzle == NULL)
 
172
  {
 
173
    return;
 
174
  }
 
175
 
165
176
  if (drizzle->context != NULL && drizzle->context_free_fn != NULL)
 
177
  {
166
178
    drizzle->context_free_fn(drizzle, drizzle->context);
 
179
  }
167
180
 
168
181
  if (drizzle->options & DRIZZLE_FREE_OBJECTS)
169
182
  {
190
203
 
191
204
const char *drizzle_error(const drizzle_st *drizzle)
192
205
{
 
206
  if (drizzle == NULL)
 
207
  {
 
208
    return NULL;
 
209
  }
 
210
 
193
211
  return (const char *)drizzle->last_error;
194
212
}
195
213
 
196
214
int drizzle_errno(const drizzle_st *drizzle)
197
215
{
 
216
  if (drizzle == NULL)
 
217
  {
 
218
    return 0;
 
219
  }
 
220
 
198
221
  return drizzle->last_errno;
199
222
}
200
223
 
201
224
uint16_t drizzle_error_code(const drizzle_st *drizzle)
202
225
{
 
226
  if (drizzle == NULL)
 
227
  {
 
228
    return 0;
 
229
  }
 
230
 
203
231
  return drizzle->error_code;
204
232
}
205
233
 
206
234
const char *drizzle_sqlstate(const drizzle_st *drizzle)
207
235
{
 
236
  if (drizzle == NULL)
 
237
  {
 
238
    return NULL;
 
239
  }
 
240
 
208
241
  return drizzle->sqlstate;
209
242
}
210
243
 
211
244
drizzle_options_t drizzle_options(const drizzle_st *drizzle)
212
245
{
 
246
  if (drizzle == NULL)
 
247
  {
 
248
    return drizzle_options_t();
 
249
  }
 
250
 
213
251
  return drizzle_options_t(drizzle->options);
214
252
}
215
253
 
216
254
void drizzle_set_options(drizzle_st *drizzle, drizzle_options_t options)
217
255
{
 
256
  if (drizzle == NULL)
 
257
  {
 
258
    return;
 
259
  }
 
260
 
218
261
  drizzle->options= options;
219
262
}
220
263
 
221
264
void drizzle_add_options(drizzle_st *drizzle, drizzle_options_t options)
222
265
{
 
266
  if (drizzle == NULL)
 
267
  {
 
268
    return;
 
269
  }
 
270
 
223
271
  drizzle->options|= options;
224
272
}
225
273
 
226
274
void drizzle_remove_options(drizzle_st *drizzle, drizzle_options_t options)
227
275
{
 
276
  if (drizzle == NULL)
 
277
  {
 
278
    return;
 
279
  }
 
280
 
228
281
  drizzle->options&= ~options;
229
282
}
230
283
 
231
284
void *drizzle_context(const drizzle_st *drizzle)
232
285
{
 
286
  if (drizzle == NULL)
 
287
  {
 
288
    return NULL;
 
289
  }
 
290
 
233
291
  return drizzle->context;
234
292
}
235
293
 
236
294
void drizzle_set_context(drizzle_st *drizzle, void *context)
237
295
{
 
296
  if (drizzle == NULL)
 
297
  {
 
298
    return;
 
299
  }
 
300
 
238
301
  drizzle->context= context;
239
302
}
240
303
 
241
304
void drizzle_set_context_free_fn(drizzle_st *drizzle,
242
305
                                 drizzle_context_free_fn *function)
243
306
{
 
307
  if (drizzle == NULL)
 
308
  {
 
309
    return;
 
310
  }
 
311
 
244
312
  drizzle->context_free_fn= function;
245
313
}
246
314
 
247
315
int drizzle_timeout(const drizzle_st *drizzle)
248
316
{
 
317
  if (drizzle == NULL)
 
318
  {
 
319
    return -1;
 
320
  }
 
321
 
249
322
  return drizzle->timeout;
250
323
}
251
324
 
252
325
void drizzle_set_timeout(drizzle_st *drizzle, int timeout)
253
326
{
 
327
  if (drizzle == NULL)
 
328
  {
 
329
    return;
 
330
  }
 
331
 
254
332
  drizzle->timeout= timeout;
255
333
}
256
334
 
257
335
drizzle_verbose_t drizzle_verbose(const drizzle_st *drizzle)
258
336
{
 
337
  if (drizzle == NULL)
 
338
  {
 
339
    return drizzle_verbose_t();
 
340
  }
 
341
 
259
342
  return drizzle->verbose;
260
343
}
261
344
 
262
345
void drizzle_set_verbose(drizzle_st *drizzle, drizzle_verbose_t verbose)
263
346
{
 
347
  if (drizzle == NULL)
 
348
  {
 
349
    return;
 
350
  }
 
351
 
264
352
  drizzle->verbose= verbose;
265
353
}
266
354
 
267
355
void drizzle_set_log_fn(drizzle_st *drizzle, drizzle_log_fn *function,
268
356
                        void *context)
269
357
{
 
358
  if (drizzle == NULL)
 
359
  {
 
360
    return;
 
361
  }
 
362
 
270
363
  drizzle->log_fn= function;
271
364
  drizzle->log_context= context;
272
365
}
275
368
                                drizzle_event_watch_fn *function,
276
369
                                void *context)
277
370
{
 
371
  if (drizzle == NULL)
 
372
  {
 
373
    return;
 
374
  }
 
375
 
278
376
  drizzle->event_watch_fn= function;
279
377
  drizzle->event_watch_context= context;
280
378
}
281
379
 
282
380
drizzle_con_st *drizzle_con_create(drizzle_st *drizzle, drizzle_con_st *con)
283
381
{
 
382
  if (drizzle == NULL)
 
383
  {
 
384
    return NULL;
 
385
  }
 
386
 
284
387
  if (con == NULL)
285
388
  {
286
389
    con= new (std::nothrow) drizzle_con_st;
287
390
    if (con == NULL)
288
391
    {
289
392
      if (drizzle != NULL)
 
393
      {
290
394
        drizzle_set_error(drizzle, "drizzle_con_create", "malloc");
 
395
      }
 
396
 
291
397
      return NULL;
292
398
    }
293
399
 
294
400
    con->options= DRIZZLE_CON_ALLOCATED;
295
401
  }
296
402
  else
 
403
  {
297
404
    con->options= 0;
 
405
  }
298
406
 
299
407
  if (drizzle->con_list != NULL)
 
408
  {
300
409
    drizzle->con_list->prev= con;
 
410
  }
301
411
  con->next= drizzle->con_list;
302
412
  con->prev= NULL;
303
413
  drizzle->con_list= con;
354
464
drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *con,
355
465
                                  const drizzle_con_st *from)
356
466
{
 
467
  if (drizzle == NULL)
 
468
  {
 
469
    return NULL;
 
470
  }
 
471
 
357
472
  con= drizzle_con_create(drizzle, con);
358
473
  if (con == NULL)
 
474
  {
359
475
    return NULL;
 
476
  }
360
477
 
361
478
  /* Clear "operational" options such as IO status. */
362
479
  con->options|= (from->options & int(~(
387
504
 
388
505
void drizzle_con_free(drizzle_con_st *con)
389
506
{
390
 
  if (con->context != NULL && con->context_free_fn != NULL)
 
507
  if (con == NULL)
 
508
  {
 
509
    return;
 
510
  }
 
511
 
 
512
  if (con->context != NULL and con->context_free_fn != NULL)
 
513
  {
391
514
    con->context_free_fn(con, con->context);
 
515
  }
392
516
 
393
517
  if (con->drizzle->options & DRIZZLE_FREE_OBJECTS)
 
518
  {
394
519
    drizzle_result_free_all(con);
 
520
  }
395
521
  else if (con->drizzle->options & DRIZZLE_ASSERT_DANGLING)
 
522
  {
396
523
    assert(con->result_list == NULL);
 
524
  }
397
525
 
398
526
  if (con->fd != -1)
 
527
  {
399
528
    drizzle_con_close(con);
 
529
  }
400
530
 
401
531
  drizzle_con_reset_addrinfo(con);
402
532
 
403
533
  if (con->drizzle->con_list == con)
404
534
    con->drizzle->con_list= con->next;
 
535
 
405
536
  if (con->prev != NULL)
406
537
    con->prev->next= con->next;
 
538
 
407
539
  if (con->next != NULL)
408
540
    con->next->prev= con->prev;
 
541
 
409
542
  con->drizzle->con_count--;
410
543
 
411
544
  if (con->options & DRIZZLE_CON_ALLOCATED)
422
555
 
423
556
drizzle_return_t drizzle_con_wait(drizzle_st *drizzle)
424
557
{
425
 
  drizzle_con_st *con;
 
558
  if (drizzle == NULL)
 
559
  {
 
560
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
561
  }
 
562
 
426
563
  struct pollfd *pfds;
427
 
  uint32_t x;
428
 
  int ret;
429
 
  drizzle_return_t dret;
430
 
 
431
564
  if (drizzle->pfds_size < drizzle->con_count)
432
565
  {
433
566
    pfds= (struct pollfd *)realloc(drizzle->pfds, drizzle->con_count * sizeof(struct pollfd));
441
574
    drizzle->pfds_size= drizzle->con_count;
442
575
  }
443
576
  else
 
577
  {
444
578
    pfds= drizzle->pfds;
 
579
  }
445
580
 
446
 
  x= 0;
447
 
  for (con= drizzle->con_list; con != NULL; con= con->next)
 
581
  uint32_t x= 0;
 
582
  for (drizzle_con_st *con= drizzle->con_list; con != NULL; con= con->next)
448
583
  {
449
584
    if (con->events == 0)
 
585
    {
450
586
      continue;
 
587
    }
451
588
 
452
589
    pfds[x].fd= con->fd;
453
590
    pfds[x].events= con->events;
462
599
    return DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS;
463
600
  }
464
601
 
 
602
  int ret;
465
603
  while (1)
466
604
  {
467
605
    drizzle_log_crazy(drizzle, "poll count=%d timeout=%d", x,
474
612
    if (ret == -1)
475
613
    {
476
614
      if (errno == EINTR)
 
615
      {
477
616
        continue;
 
617
      }
478
618
 
479
619
      drizzle_set_error(drizzle, "drizzle_con_wait", "poll:%d", errno);
480
620
      drizzle->last_errno= errno;
491
631
  }
492
632
 
493
633
  x= 0;
494
 
  for (con= drizzle->con_list; con != NULL; con= con->next)
 
634
  for (drizzle_con_st *con= drizzle->con_list; con != NULL; con= con->next)
495
635
  {
496
636
    if (con->events == 0)
 
637
    {
497
638
      continue;
 
639
    }
498
640
 
499
 
    dret= drizzle_con_set_revents(con, pfds[x].revents);
 
641
    drizzle_return_t dret= drizzle_con_set_revents(con, pfds[x].revents);
500
642
    if (dret != DRIZZLE_RETURN_OK)
 
643
    {
501
644
      return dret;
 
645
    }
502
646
 
503
647
    x++;
504
648
  }
508
652
 
509
653
drizzle_con_st *drizzle_con_ready(drizzle_st *drizzle)
510
654
{
511
 
  drizzle_con_st *con;
 
655
  if (drizzle == NULL)
 
656
  {
 
657
    return NULL;
 
658
  }
512
659
 
513
660
  /* We can't keep state between calls since connections may be removed during
514
661
     processing. If this list ever gets big, we may want something faster. */
515
662
 
516
 
  for (con= drizzle->con_list; con != NULL; con= con->next)
 
663
  for (drizzle_con_st *con= drizzle->con_list; con != NULL; con= con->next)
517
664
  {
518
665
    if (con->options & DRIZZLE_CON_IO_READY)
519
666
    {
527
674
 
528
675
drizzle_con_st *drizzle_con_ready_listen(drizzle_st *drizzle)
529
676
{
530
 
  drizzle_con_st *con;
 
677
  if (drizzle == NULL)
 
678
  {
 
679
    return NULL;
 
680
  }
531
681
 
532
682
  /* We can't keep state between calls since connections may be removed during
533
683
     processing. If this list ever gets big, we may want something faster. */
534
684
 
535
 
  for (con= drizzle->con_list; con != NULL; con= con->next)
 
685
  for (drizzle_con_st *con= drizzle->con_list; con != NULL; con= con->next)
536
686
  {
537
687
    if ((con->options & (DRIZZLE_CON_IO_READY | DRIZZLE_CON_LISTEN)) ==
538
688
        (DRIZZLE_CON_IO_READY | DRIZZLE_CON_LISTEN))
555
705
                                    const char *db,
556
706
                                    drizzle_con_options_t options)
557
707
{
 
708
  if (drizzle == NULL)
 
709
  {
 
710
    return NULL;
 
711
  }
 
712
 
558
713
  con= drizzle_con_create(drizzle, con);
559
714
  if (con == NULL)
 
715
  {
560
716
    return NULL;
 
717
  }
561
718
 
562
719
  drizzle_con_set_tcp(con, host, port);
563
720
  drizzle_con_set_auth(con, user, password);
572
729
                                    const char *password, const char *db,
573
730
                                    drizzle_con_options_t options)
574
731
{
 
732
  if (drizzle == NULL)
 
733
  {
 
734
    return NULL;
 
735
  }
 
736
 
575
737
  con= drizzle_con_create(drizzle, con);
576
738
  if (con == NULL)
 
739
  {
577
740
    return NULL;
 
741
  }
578
742
 
579
743
  drizzle_con_set_uds(con, uds);
580
744
  drizzle_con_set_auth(con, user, password);
594
758
                                           int backlog,
595
759
                                           drizzle_con_options_t options)
596
760
{
 
761
  if (drizzle == NULL)
 
762
  {
 
763
    return NULL;
 
764
  }
 
765
 
597
766
  con= drizzle_con_create(drizzle, con);
598
767
  if (con == NULL)
 
768
  {
599
769
    return NULL;
 
770
  }
600
771
 
601
772
  drizzle_con_set_tcp(con, host, port);
602
773
  drizzle_con_set_backlog(con, backlog);
610
781
                                           const char *uds, int backlog,
611
782
                                           drizzle_con_options_t options)
612
783
{
 
784
  if (drizzle == NULL)
 
785
  {
 
786
    return NULL;
 
787
  }
 
788
 
613
789
  con= drizzle_con_create(drizzle, con);
614
790
  if (con == NULL)
 
791
  {
615
792
    return NULL;
 
793
  }
616
794
 
617
795
  drizzle_con_set_uds(con, uds);
618
796
  drizzle_con_set_backlog(con, backlog);
624
802
drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle, drizzle_con_st *con,
625
803
                                   drizzle_return_t *ret_ptr)
626
804
{
627
 
  drizzle_con_st *ready;
628
 
  int fd;
 
805
  drizzle_return_t unused_ret;
 
806
  if (ret_ptr == NULL)
 
807
  {
 
808
    ret_ptr= &unused_ret;
 
809
  }
 
810
 
 
811
  if (drizzle == NULL)
 
812
  {
 
813
    return NULL;
 
814
  }
629
815
 
630
816
  while (1)
631
817
  {
 
818
    drizzle_con_st *ready;
 
819
 
632
820
    if ((ready= drizzle_con_ready_listen(drizzle)) != NULL)
633
821
    {
634
 
      fd= accept(ready->fd, NULL, NULL);
 
822
      int fd= accept(ready->fd, NULL, NULL);
635
823
 
636
824
      con= drizzle_con_create(drizzle, con);
637
825
      if (con == NULL)
680
868
void drizzle_set_error(drizzle_st *drizzle, const char *function,
681
869
                       const char *format, ...)
682
870
{
 
871
  if (drizzle == NULL)
 
872
  {
 
873
    return;
 
874
  }
 
875
 
683
876
  size_t size;
684
877
  int written;
685
878
  char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
696
889
  written= vsnprintf(ptr, DRIZZLE_MAX_ERROR_SIZE - size, format, args);
697
890
  va_end(args);
698
891
 
699
 
  if (written < 0) size= DRIZZLE_MAX_ERROR_SIZE;
700
 
  else size+= written;
 
892
  if (written < 0)
 
893
  {
 
894
    size= DRIZZLE_MAX_ERROR_SIZE;
 
895
  }
 
896
  else
 
897
  {
 
898
    size+= written;
 
899
  }
 
900
 
701
901
  if (size >= DRIZZLE_MAX_ERROR_SIZE)
 
902
  {
702
903
    size= DRIZZLE_MAX_ERROR_SIZE - 1;
 
904
  }
703
905
  log_buffer[size]= 0;
704
906
 
705
907
  if (drizzle->log_fn == NULL)
 
908
  {
706
909
    memcpy(drizzle->last_error, log_buffer, size + 1);
 
910
  }
707
911
  else
 
912
  {
708
913
    drizzle->log_fn(log_buffer, DRIZZLE_VERBOSE_ERROR, drizzle->log_context);
 
914
  }
709
915
}
710
916
 
711
917
void drizzle_log(drizzle_st *drizzle, drizzle_verbose_t verbose,
712
918
                 const char *format, va_list args)
713
919
{
 
920
  if (drizzle == NULL)
 
921
  {
 
922
    return;
 
923
  }
 
924
 
714
925
  char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
715
926
 
716
927
  if (drizzle->log_fn == NULL)