← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/column.cc

  • Committer: Brian Aker
  • Date: 2011-11-18 02:03:41 UTC
  • mto: (2463.1.1 drizzle-include)
  • mto: This revision was merged to the branch mainline in revision 2462.
  • Revision ID: brian@tangent.org-20111118020341-mgz2m1kjo62al44e
Fix safety issues around calling API with no check for NULL

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/column.cc
354
354
drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
355
355
                                         drizzle_column_st *column)
356
356
{
 
357
  if (result == NULL)
 
358
  {
 
359
    return NULL;
 
360
  }
 
361
 
357
362
  if (column == NULL)
358
363
  {
359
 
    column= new drizzle_column_st;
360
 
    column->result = result;
 
364
    column= new (std::nothrow)drizzle_column_st;
 
365
    column->result= result;
361
366
    /* SET BELOW: column->next */
362
 
    column->prev = NULL;
 
367
    column->prev= NULL;
363
368
    column->options= DRIZZLE_COLUMN_ALLOCATED;
364
 
    column->catalog[0] = '\0';
365
 
    column->db[0] = '\0';
366
 
    column->table[0] = '\0';
367
 
    column->orig_table[0] = '\0';
368
 
    column->name[0] = '\0';
369
 
    column->orig_name[0] = '\0';
370
 
    column->charset = 0;
371
 
    column->size = 0;
372
 
    column->max_size = 0;
373
 
    column->type = static_cast<drizzle_column_type_t>(0);
374
 
    column->flags = drizzle_column_flags_t();
375
 
    column->decimals = 0;
 
369
    column->catalog[0]= '\0';
 
370
    column->schema[0]= '\0';
 
371
    column->table[0]= '\0';
 
372
    column->orig_table[0]= '\0';
 
373
    column->name[0]= '\0';
 
374
    column->orig_name[0]= '\0';
 
375
    column->charset= 0;
 
376
    column->size= 0;
 
377
    column->max_size= 0;
 
378
    column->type= static_cast<drizzle_column_type_t>(0);
 
379
    column->flags= drizzle_column_flags_t();
 
380
    column->decimals= 0;
376
381
    /* UNSET: column->default_value */
377
 
    column->default_value_size = 0;
378
 
 
 
382
    column->default_value_size= 0;
379
383
  }
380
384
  else
381
385
  {
384
388
    column->prev = NULL;
385
389
    column->options= drizzle_column_options_t();
386
390
    column->catalog[0] = '\0';
387
 
    column->db[0] = '\0';
 
391
    column->schema[0] = '\0';
388
392
    column->table[0] = '\0';
389
393
    column->orig_table[0] = '\0';
390
394
    column->name[0] = '\0';
411
415
 
412
416
void drizzle_column_free(drizzle_column_st *column)
413
417
{
 
418
  if (column == NULL)
 
419
  {
 
420
    return;
 
421
  }
 
422
 
414
423
  if (column->result->column_list == column)
 
424
  {
415
425
    column->result->column_list= column->next;
 
426
  }
 
427
 
416
428
  if (column->prev)
 
429
  {
417
430
    column->prev->next= column->next;
 
431
  }
 
432
 
418
433
  if (column->next)
 
434
  {
419
435
    column->next->prev= column->prev;
 
436
  }
420
437
 
421
438
  if (column->options & DRIZZLE_COLUMN_ALLOCATED)
 
439
  {
422
440
    delete column;
 
441
  }
423
442
}
424
443
 
425
444
drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
426
445
{
 
446
  if (column == NULL)
 
447
  {
 
448
    return NULL;
 
449
  }
 
450
 
427
451
  return column->result;
428
452
}
429
453
 
430
454
const char *drizzle_column_catalog(drizzle_column_st *column)
431
455
{
 
456
  if (column == NULL)
 
457
  {
 
458
    return NULL;
 
459
  }
 
460
 
432
461
  return column->catalog;
433
462
}
434
463
 
 
464
const char *drizzle_column_shema(drizzle_column_st *column)
 
465
{
 
466
  if (column == NULL)
 
467
  {
 
468
    return NULL;
 
469
  }
 
470
 
 
471
  return column->schema;
 
472
}
 
473
 
435
474
const char *drizzle_column_db(drizzle_column_st *column)
436
475
{
437
 
  return column->db;
 
476
  return drizzle_column_shema(column);
438
477
}
439
478
 
440
479
const char *drizzle_column_table(drizzle_column_st *column)
441
480
{
 
481
  if (column == NULL)
 
482
  {
 
483
    return NULL;
 
484
  }
 
485
 
442
486
  return column->table;
443
487
}
444
488
 
445
489
const char *drizzle_column_orig_table(drizzle_column_st *column)
446
490
{
 
491
  if (column == NULL)
 
492
  {
 
493
    return NULL;
 
494
  }
 
495
 
447
496
  return column->orig_table;
448
497
}
449
498
 
450
499
const char *drizzle_column_name(drizzle_column_st *column)
451
500
{
 
501
  if (column == NULL)
 
502
  {
 
503
    return NULL;
 
504
  }
 
505
 
452
506
  return column->name;
453
507
}
454
508
 
455
509
const char *drizzle_column_orig_name(drizzle_column_st *column)
456
510
{
 
511
  if (column == NULL)
 
512
  {
 
513
    return NULL;
 
514
  }
 
515
 
457
516
  return column->orig_name;
458
517
}
459
518
 
460
519
drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
461
520
{
 
521
  if (column == NULL)
 
522
  {
 
523
    return 0;
 
524
  }
 
525
 
462
526
  return column->charset;
463
527
}
464
528
 
465
529
uint32_t drizzle_column_size(drizzle_column_st *column)
466
530
{
 
531
  if (column == NULL)
 
532
  {
 
533
    return 0;
 
534
  }
 
535
 
467
536
  return column->size;
468
537
}
469
538
 
470
539
size_t drizzle_column_max_size(drizzle_column_st *column)
471
540
{
 
541
  if (column == NULL)
 
542
  {
 
543
    return 0;
 
544
  }
 
545
 
472
546
  return column->max_size;
473
547
}
474
548
 
475
549
void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
476
550
{
 
551
  if (column == NULL)
 
552
  {
 
553
    return;
 
554
  }
 
555
 
477
556
  column->max_size= size;
478
557
}
479
558
 
480
559
drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
481
560
{
 
561
  if (column == NULL)
 
562
  {
 
563
    return drizzle_column_type_t();
 
564
  }
 
565
 
482
566
  return column->type;
483
567
}
484
568
 
485
 
drizzle_column_type_drizzle_t
486
 
drizzle_column_type_drizzle(drizzle_column_st *column)
 
569
drizzle_column_type_drizzle_t drizzle_column_type_drizzle(drizzle_column_st *column)
487
570
{
 
571
  if (column == NULL)
 
572
  {
 
573
    return drizzle_column_type_drizzle_t();
 
574
  }
 
575
 
488
576
  return _column_type_drizzle_map_from[column->type];
489
577
}
490
578
 
491
579
int drizzle_column_flags(drizzle_column_st *column)
492
580
{
 
581
  if (column == NULL)
 
582
  {
 
583
    return 0;
 
584
  }
 
585
 
493
586
  return column->flags;
494
587
}
495
588
 
496
589
uint8_t drizzle_column_decimals(drizzle_column_st *column)
497
590
{
 
591
  if (column == NULL)
 
592
  {
 
593
    return 0;
 
594
  }
 
595
 
498
596
  return column->decimals;
499
597
}
500
598
 
511
609
 
512
610
drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
513
611
{
514
 
  drizzle_return_t ret;
 
612
  if (result == NULL)
 
613
  {
 
614
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
615
  }
 
616
 
515
617
  if (drizzle_state_none(result->con))
516
618
  {
517
619
    result->options|= DRIZZLE_RESULT_SKIP_COLUMN;
519
621
    drizzle_state_push(result->con, drizzle_state_column_read);
520
622
    drizzle_state_push(result->con, drizzle_state_packet_read);
521
623
  }
522
 
  ret= drizzle_state_loop(result->con);
 
624
  drizzle_return_t ret= drizzle_state_loop(result->con);
523
625
  result->options&= ~DRIZZLE_RESULT_SKIP_COLUMN;
524
626
  return ret;
525
627
}
526
628
 
527
629
drizzle_return_t drizzle_column_skip_all(drizzle_result_st *result)
528
630
{
529
 
  drizzle_return_t ret;
530
 
  uint16_t it;
 
631
  if (result == NULL)
 
632
  {
 
633
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
634
  }
531
635
 
532
 
  for (it= 1; it <= result->column_count; it++)
 
636
  for (uint16_t it= 1; it <= result->column_count; it++)
533
637
  {
534
 
    ret= drizzle_column_skip(result);
 
638
    drizzle_return_t ret= drizzle_column_skip(result);
535
639
    if (ret != DRIZZLE_RETURN_OK)
 
640
    {
536
641
      return ret;
 
642
    }
537
643
  }
538
644
 
539
645
  return DRIZZLE_RETURN_OK;
543
649
                                       drizzle_column_st *column,
544
650
                                       drizzle_return_t *ret_ptr)
545
651
{
 
652
  if (result == NULL)
 
653
  {
 
654
    return NULL;
 
655
  }
 
656
 
546
657
  if (drizzle_state_none(result->con))
547
658
  {
548
659
    result->column= column;
557
668
 
558
669
drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
559
670
{
 
671
  if (result == NULL)
 
672
  {
 
673
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
674
  }
 
675
 
560
676
  drizzle_return_t ret;
561
677
 
562
678
  if (result->column_buffer == NULL)
587
703
 
588
704
drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
589
705
{
 
706
  if (result == NULL)
 
707
  {
 
708
    return NULL;
 
709
  }
 
710
 
590
711
  if (result->column_current == result->column_count)
 
712
  {
591
713
    return NULL;
 
714
  }
592
715
 
593
716
  result->column_current++;
594
717
  return &(result->column_buffer[result->column_current - 1]);
605
728
 
606
729
void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
607
730
{
 
731
  if (result == NULL)
 
732
  {
 
733
    return;
 
734
  }
 
735
 
608
736
  if (column <= result->column_count)
 
737
  {
609
738
    result->column_current= column;
 
739
  }
610
740
}
611
741
 
612
 
drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
613
 
                                        uint16_t column)
 
742
drizzle_column_st *drizzle_column_index(drizzle_result_st *result, uint16_t column)
614
743
{
 
744
  if (result == NULL)
 
745
  {
 
746
    return NULL;
 
747
  }
 
748
 
615
749
  if (column >= result->column_count)
 
750
  {
616
751
    return NULL;
 
752
  }
617
753
 
618
754
  return &(result->column_buffer[column]);
619
755
}
620
756
 
621
757
uint16_t drizzle_column_current(drizzle_result_st *result)
622
758
{
 
759
  if (result == NULL)
 
760
  {
 
761
    return 0;
 
762
  }
 
763
 
623
764
  return result->column_current;
624
765
}
625
766
 
630
771
drizzle_return_t drizzle_column_write(drizzle_result_st *result,
631
772
                                      drizzle_column_st *column)
632
773
{
 
774
  if (result == NULL)
 
775
  {
 
776
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
777
  }
 
778
 
633
779
  if (drizzle_state_none(result->con))
634
780
  {
635
781
    result->column= column;
642
788
 
643
789
void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
644
790
{
 
791
  if (column == NULL)
 
792
  {
 
793
    return;
 
794
  }
 
795
 
645
796
  if (catalog == NULL)
 
797
  {
646
798
    column->catalog[0]= 0;
 
799
  }
647
800
  else
648
801
  {
649
802
    strncpy(column->catalog, catalog, DRIZZLE_MAX_CATALOG_SIZE);
651
804
  }
652
805
}
653
806
 
654
 
void drizzle_column_set_db(drizzle_column_st *column, const char *db)
 
807
void drizzle_column_set_schema(drizzle_column_st *column, const char *schema)
655
808
{
656
 
  if (db == NULL)
657
 
    column->db[0]= 0;
 
809
  if (column == NULL)
 
810
  {
 
811
    return;
 
812
  }
 
813
 
 
814
  if (schema == NULL)
 
815
  {
 
816
    column->schema[0]= 0;
 
817
  }
658
818
  else
659
819
  {
660
 
    strncpy(column->db, db, DRIZZLE_MAX_DB_SIZE);
661
 
    column->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
 
820
    strncpy(column->schema, schema, DRIZZLE_MAX_DB_SIZE);
 
821
    column->schema[DRIZZLE_MAX_DB_SIZE - 1]= 0;
662
822
  }
663
823
}
664
824
 
 
825
void drizzle_column_set_db(drizzle_column_st *column, const char *schema)
 
826
{
 
827
  drizzle_column_set_schema(column, schema);
 
828
}
 
829
 
 
830
 
665
831
void drizzle_column_set_table(drizzle_column_st *column, const char *table)
666
832
{
 
833
  if (column == NULL)
 
834
  {
 
835
    return;
 
836
  }
 
837
 
667
838
  if (table == NULL)
 
839
  {
668
840
    column->table[0]= 0;
 
841
  }
669
842
  else
670
843
  {
671
844
    strncpy(column->table, table, DRIZZLE_MAX_TABLE_SIZE);
676
849
void drizzle_column_set_orig_table(drizzle_column_st *column,
677
850
                                   const char *orig_table)
678
851
{
 
852
  if (column == NULL)
 
853
  {
 
854
    return;
 
855
  }
 
856
 
679
857
  if (orig_table == NULL)
680
858
    column->orig_table[0]= 0;
681
859
  else
687
865
 
688
866
void drizzle_column_set_name(drizzle_column_st *column, const char *name)
689
867
{
 
868
  if (column == NULL)
 
869
  {
 
870
    return;
 
871
  }
 
872
 
690
873
  if (name == NULL)
691
874
    column->name[0]= 0;
692
875
  else
699
882
void drizzle_column_set_orig_name(drizzle_column_st *column,
700
883
                                  const char *orig_name)
701
884
{
 
885
  if (column == NULL)
 
886
  {
 
887
    return;
 
888
  }
 
889
 
702
890
  if (orig_name == NULL)
703
891
    column->orig_name[0]= 0;
704
892
  else
711
899
void drizzle_column_set_charset(drizzle_column_st *column,
712
900
                                drizzle_charset_t charset)
713
901
{
 
902
  if (column == NULL)
 
903
  {
 
904
    return;
 
905
  }
 
906
 
714
907
  column->charset= charset;
715
908
}
716
909
 
717
910
void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
718
911
{
 
912
  if (column == NULL)
 
913
  {
 
914
    return;
 
915
  }
 
916
 
719
917
  column->size= size;
720
918
}
721
919
 
722
920
void drizzle_column_set_type(drizzle_column_st *column,
723
921
                             drizzle_column_type_t type)
724
922
{
 
923
  if (column == NULL)
 
924
  {
 
925
    return;
 
926
  }
 
927
 
725
928
  column->type= type;
726
929
}
727
930
 
728
931
void drizzle_column_set_flags(drizzle_column_st *column,
729
932
                              int flags)
730
933
{
 
934
  if (column == NULL)
 
935
  {
 
936
    return;
 
937
  }
 
938
 
731
939
  column->flags= flags;
732
940
}
733
941
 
734
942
void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
735
943
{
 
944
  if (column == NULL)
 
945
  {
 
946
    return;
 
947
  }
 
948
 
736
949
  column->decimals= decimals;
737
950
}
738
951
 
740
953
                                      const uint8_t *default_value,
741
954
                                      size_t size)
742
955
{
 
956
  if (column == NULL)
 
957
  {
 
958
    return;
 
959
  }
 
960
 
743
961
  if (default_value == NULL)
 
962
  {
744
963
    column->default_value[0]= 0;
 
964
  }
745
965
  else
746
966
  {
747
967
    if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
766
986
 
767
987
drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
768
988
{
 
989
  if (con == NULL)
 
990
  {
 
991
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
992
  }
 
993
 
769
994
  drizzle_column_st *column;
770
995
  drizzle_column_type_drizzle_t drizzle_type;
771
996
 
809
1034
    /* These functions can only fail if they need to read data, but we know we
810
1035
       buffered the entire packet, so ignore returns. */
811
1036
    (void)drizzle_unpack_string(con, column->catalog, DRIZZLE_MAX_CATALOG_SIZE);
812
 
    (void)drizzle_unpack_string(con, column->db, DRIZZLE_MAX_DB_SIZE);
 
1037
    (void)drizzle_unpack_string(con, column->schema, DRIZZLE_MAX_DB_SIZE);
813
1038
    (void)drizzle_unpack_string(con, column->table, DRIZZLE_MAX_TABLE_SIZE);
814
1039
    (void)drizzle_unpack_string(con, column->orig_table,
815
1040
                                DRIZZLE_MAX_TABLE_SIZE);
867
1092
 
868
1093
drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
869
1094
{
 
1095
  if (con == NULL)
 
1096
  {
 
1097
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1098
  }
 
1099
 
870
1100
  uint8_t *start= con->buffer_ptr + con->buffer_size;
871
1101
  uint8_t *ptr;
872
1102
  drizzle_column_st *column= con->result->column;
875
1105
 
876
1106
  /* Calculate max packet size. */
877
1107
  con->packet_size= 9 + strlen(column->catalog)
878
 
                  + 9 + strlen(column->db)
 
1108
                  + 9 + strlen(column->schema)
879
1109
                  + 9 + strlen(column->table)
880
1110
                  + 9 + strlen(column->orig_table)
881
1111
                  + 9 + strlen(column->name)
912
1142
  ptr+= 4;
913
1143
 
914
1144
  ptr= drizzle_pack_string(column->catalog, ptr);
915
 
  ptr= drizzle_pack_string(column->db, ptr);
 
1145
  ptr= drizzle_pack_string(column->schema, ptr);
916
1146
  ptr= drizzle_pack_string(column->table, ptr);
917
1147
  ptr= drizzle_pack_string(column->orig_table, ptr);
918
1148
  ptr= drizzle_pack_string(column->name, ptr);