← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/conn.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/conn.cc
267
267
  }
268
268
 
269
269
  if (password == NULL)
 
270
  {
270
271
    con->password[0]= 0;
 
272
  }
271
273
  else
272
274
  {
273
275
    strncpy(con->password, password, DRIZZLE_MAX_PASSWORD_SIZE);
275
277
  }
276
278
}
277
279
 
 
280
const char *drizzle_con_schema(const drizzle_con_st *con)
 
281
{
 
282
  if (con == NULL)
 
283
  {
 
284
    return NULL;
 
285
  }
 
286
 
 
287
  return con->schema;
 
288
}
 
289
 
278
290
const char *drizzle_con_db(const drizzle_con_st *con)
279
291
{
280
 
  return con->db;
 
292
  return drizzle_con_schema(con);
281
293
}
282
294
 
283
 
void drizzle_con_set_db(drizzle_con_st *con, const char *db)
 
295
void drizzle_con_set_schema(drizzle_con_st *con, const char *schema)
284
296
{
285
 
  if (db == NULL)
286
 
    con->db[0]= 0;
 
297
  if (con == NULL)
 
298
  {
 
299
    return;
 
300
  }
 
301
 
 
302
  if (schema == NULL)
 
303
  {
 
304
    con->schema[0]= 0;
 
305
  }
287
306
  else
288
307
  {
289
 
    strncpy(con->db, db, DRIZZLE_MAX_DB_SIZE);
290
 
    con->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
 
308
    strncpy(con->schema, schema, DRIZZLE_MAX_DB_SIZE);
 
309
    con->schema[DRIZZLE_MAX_DB_SIZE - 1]= 0;
291
310
  }
292
311
}
293
312
 
 
313
void drizzle_con_set_db(drizzle_con_st *con, const char *schema)
 
314
{
 
315
  drizzle_con_set_schema(con, schema);
 
316
}
 
317
 
294
318
void *drizzle_con_context(const drizzle_con_st *con)
295
319
{
 
320
  if (con == NULL)
 
321
  {
 
322
    return NULL;
 
323
  }
 
324
 
296
325
  return con->context;
297
326
}
298
327
 
299
328
void drizzle_con_set_context(drizzle_con_st *con, void *context)
300
329
{
 
330
  if (con == NULL)
 
331
  {
 
332
    return;
 
333
  }
 
334
 
301
335
  con->context= context;
302
336
}
303
337
 
304
338
void drizzle_con_set_context_free_fn(drizzle_con_st *con,
305
339
                                     drizzle_con_context_free_fn *function)
306
340
{
 
341
  if (con == NULL)
 
342
  {
 
343
    return;
 
344
  }
 
345
 
307
346
  con->context_free_fn= function;
308
347
}
309
348
 
310
349
uint8_t drizzle_con_protocol_version(const drizzle_con_st *con)
311
350
{
 
351
  if (con == NULL)
 
352
  {
 
353
    return 0;
 
354
  }
 
355
 
312
356
  return con->protocol_version;
313
357
}
314
358
 
315
359
const char *drizzle_con_server_version(const drizzle_con_st *con)
316
360
{
 
361
  if (con == NULL)
 
362
  {
 
363
    return NULL;
 
364
  }
 
365
 
317
366
  return con->server_version;
318
367
}
319
368
 
320
369
uint32_t drizzle_con_server_version_number(const drizzle_con_st *con)
321
370
{
322
 
  uint32_t major;
323
 
  uint32_t minor;
324
 
  uint32_t version;
 
371
  if (con == NULL)
 
372
  {
 
373
    return 0;
 
374
  }
 
375
 
 
376
  const char *current= con->server_version;
 
377
 
325
378
  char *end;
326
 
 
327
 
  const char *current= con->server_version;
328
 
 
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);
 
379
  uint32_t major= (uint32_t)strtoul(current, &end, 10);
 
380
  current= end + 1;
 
381
 
 
382
  uint32_t minor= (uint32_t)strtoul(current, &end, 10);
 
383
  current= end + 1;
 
384
 
 
385
  uint32_t version= (uint32_t)strtoul(current, &end, 10);
334
386
 
335
387
  return (major * 10000) + (minor * 100) + version;
336
388
}
337
389
 
338
390
uint32_t drizzle_con_thread_id(const drizzle_con_st *con)
339
391
{
 
392
  if (con == NULL)
 
393
  {
 
394
    return 0;
 
395
  }
 
396
 
340
397
  return con->thread_id;
341
398
}
342
399
 
343
400
const uint8_t *drizzle_con_scramble(const drizzle_con_st *con)
344
401
{
 
402
  if (con == NULL)
 
403
  {
 
404
    return 0;
 
405
  }
 
406
 
345
407
  return con->scramble;
346
408
}
347
409
 
348
410
int drizzle_con_capabilities(const drizzle_con_st *con)
349
411
{
 
412
  if (con == NULL)
 
413
  {
 
414
    return 0;
 
415
  }
 
416
 
350
417
  return con->capabilities;
351
418
}
352
419
 
353
420
drizzle_charset_t drizzle_con_charset(const drizzle_con_st *con)
354
421
{
 
422
  if (con == NULL)
 
423
  {
 
424
    return drizzle_charset_t();
 
425
  }
 
426
 
355
427
  return con->charset;
356
428
}
357
429
 
358
430
drizzle_con_status_t drizzle_con_status(const drizzle_con_st *con)
359
431
{
 
432
  if (con == NULL)
 
433
  {
 
434
    return drizzle_con_status_t();
 
435
  }
 
436
 
360
437
  return con->status;
361
438
}
362
439
 
363
440
uint32_t drizzle_con_max_packet_size(const drizzle_con_st *con)
364
441
{
 
442
  if (con == NULL)
 
443
  {
 
444
    return 0;
 
445
  }
 
446
 
365
447
  return con->max_packet_size;
366
448
}
367
449
 
371
453
 
372
454
drizzle_return_t drizzle_con_connect(drizzle_con_st *con)
373
455
{
 
456
  if (con == NULL)
 
457
  {
 
458
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
459
  }
 
460
 
374
461
  if (con->options & DRIZZLE_CON_READY)
 
462
  {
375
463
    return DRIZZLE_RETURN_OK;
 
464
  }
376
465
 
377
466
  if (drizzle_state_none(con))
378
467
  {
426
515
                                        drizzle_result_st *result,
427
516
                                        drizzle_return_t *ret_ptr)
428
517
{
 
518
  if (con == NULL)
 
519
  {
 
520
    return NULL;
 
521
  }
 
522
 
429
523
  if (con->options & DRIZZLE_CON_MYSQL)
430
524
  {
431
525
    return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_SHUTDOWN,
437
531
}
438
532
 
439
533
drizzle_result_st *drizzle_shutdown(drizzle_con_st *con,
440
 
                                    drizzle_result_st *result, uint32_t level,
 
534
                                    drizzle_result_st *result, uint32_t,
441
535
                                    drizzle_return_t *ret_ptr)
442
536
{
443
 
  (void) level;
444
537
  return drizzle_con_shutdown(con, result, ret_ptr);
445
538
}
446
539
 
476
569
                                             size_t total,
477
570
                                             drizzle_return_t *ret_ptr)
478
571
{
479
 
  drizzle_result_st *old_result;
 
572
  if (con == NULL)
 
573
  {
 
574
    return NULL;
 
575
  }
480
576
 
481
577
  drizzle_return_t unused;
482
578
  if (ret_ptr == NULL)
484
580
    ret_ptr= &unused;
485
581
  }
486
582
 
487
 
  if (!(con->options & DRIZZLE_CON_READY))
 
583
  if ((con->options & DRIZZLE_CON_READY) == 0)
488
584
  {
489
585
    if (con->options & DRIZZLE_CON_RAW_PACKET)
490
586
    {
491
 
      drizzle_set_error(con->drizzle, "drizzle_command_write",
492
 
                        "connection not ready");
 
587
      drizzle_set_error(con->drizzle, "drizzle_command_write", "connection not ready");
493
588
      *ret_ptr= DRIZZLE_RETURN_NOT_READY;
494
589
      return result;
495
590
    }
509
604
    }
510
605
    else
511
606
    {
512
 
      for (old_result= con->result_list; old_result != NULL; old_result= old_result->next)
 
607
      for (drizzle_result_st *old_result= con->result_list; old_result != NULL; old_result= old_result->next)
513
608
      {
514
609
        if (result == old_result)
515
610
        {
543
638
 
544
639
  *ret_ptr= drizzle_state_loop(con);
545
640
  if (*ret_ptr == DRIZZLE_RETURN_PAUSE)
 
641
  {
546
642
    *ret_ptr= DRIZZLE_RETURN_OK;
 
643
  }
547
644
  else if (*ret_ptr != DRIZZLE_RETURN_OK &&
548
645
           *ret_ptr != DRIZZLE_RETURN_IO_WAIT &&
549
646
           *ret_ptr != DRIZZLE_RETURN_ERROR_CODE)
561
658
 
562
659
drizzle_return_t drizzle_con_listen(drizzle_con_st *con)
563
660
{
 
661
  if (con == NULL)
 
662
  {
 
663
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
664
  }
 
665
 
564
666
  if (con->options & DRIZZLE_CON_READY)
 
667
  {
565
668
    return DRIZZLE_RETURN_OK;
 
669
  }
566
670
 
567
671
  if (drizzle_state_none(con))
568
672
  {
575
679
 
576
680
int drizzle_con_backlog(const drizzle_con_st *con)
577
681
{
 
682
  if (con == NULL)
 
683
  {
 
684
    return 0;
 
685
  }
 
686
 
578
687
  return con->backlog;
579
688
}
580
689
 
581
690
void drizzle_con_set_backlog(drizzle_con_st *con, int backlog)
582
691
{
 
692
  if (con == NULL)
 
693
  {
 
694
    return;
 
695
  }
 
696
 
583
697
  con->backlog= backlog;
584
698
}
585
699
 
586
700
void drizzle_con_set_protocol_version(drizzle_con_st *con,
587
701
                                      uint8_t protocol_version)
588
702
{
 
703
  if (con == NULL)
 
704
  {
 
705
    return;
 
706
  }
 
707
 
589
708
  con->protocol_version= protocol_version;
590
709
}
591
710
 
592
711
void drizzle_con_set_server_version(drizzle_con_st *con,
593
712
                                    const char *server_version)
594
713
{
 
714
  if (con == NULL)
 
715
  {
 
716
    return;
 
717
  }
 
718
 
595
719
  if (server_version == NULL)
 
720
  {
596
721
    con->server_version[0]= 0;
 
722
  }
597
723
  else
598
724
  {
599
725
    strncpy(con->server_version, server_version,
604
730
 
605
731
void drizzle_con_set_thread_id(drizzle_con_st *con, uint32_t thread_id)
606
732
{
 
733
  if (con == NULL)
 
734
  {
 
735
    return;
 
736
  }
 
737
 
607
738
  con->thread_id= thread_id;
608
739
}
609
740
 
610
741
void drizzle_con_set_scramble(drizzle_con_st *con, const uint8_t *scramble)
611
742
{
 
743
  if (con == NULL)
 
744
  {
 
745
    return;
 
746
  }
 
747
 
612
748
  if (scramble == NULL)
 
749
  {
613
750
    con->scramble= NULL;
 
751
  }
614
752
  else
615
753
  {
616
754
    con->scramble= con->scramble_buffer;
621
759
void drizzle_con_set_capabilities(drizzle_con_st *con,
622
760
                                  int capabilities)
623
761
{
 
762
  if (con == NULL)
 
763
  {
 
764
    return;
 
765
  }
 
766
 
624
767
  con->capabilities= capabilities;
625
768
}
626
769
 
627
770
void drizzle_con_set_charset(drizzle_con_st *con, drizzle_charset_t charset)
628
771
{
 
772
  if (con == NULL)
 
773
  {
 
774
    return;
 
775
  }
 
776
 
629
777
  con->charset= charset;
630
778
}
631
779
 
632
780
void drizzle_con_set_status(drizzle_con_st *con, drizzle_con_status_t status)
633
781
{
 
782
  if (con == NULL)
 
783
  {
 
784
    return;
 
785
  }
 
786
 
634
787
  con->status= status;
635
788
}
636
789
 
637
790
void drizzle_con_set_max_packet_size(drizzle_con_st *con,
638
791
                                     uint32_t max_packet_size)
639
792
{
 
793
  if (con == NULL)
 
794
  {
 
795
    return;
 
796
  }
 
797
 
640
798
  con->max_packet_size= max_packet_size;
641
799
}
642
800
 
643
801
void drizzle_con_copy_handshake(drizzle_con_st *con, drizzle_con_st *from)
644
802
{
 
803
  if (con == NULL)
 
804
  {
 
805
    return;
 
806
  }
 
807
 
645
808
  drizzle_con_set_auth(con, from->user, NULL);
646
809
  drizzle_con_set_scramble(con, from->scramble);
647
 
  drizzle_con_set_db(con, from->db);
 
810
  drizzle_con_set_db(con, from->schema);
648
811
  drizzle_con_set_protocol_version(con, from->protocol_version);
649
812
  drizzle_con_set_server_version(con, from->server_version);
650
813
  drizzle_con_set_thread_id(con, from->thread_id);
660
823
                               size_t *size, size_t *total,
661
824
                               drizzle_return_t *ret_ptr)
662
825
{
 
826
  if (con == NULL)
 
827
  {
 
828
    return NULL;
 
829
  }
 
830
 
 
831
  drizzle_return_t unused;
 
832
  if (ret_ptr == NULL)
 
833
  {
 
834
    ret_ptr= &unused;
 
835
  }
 
836
 
663
837
  if (drizzle_state_none(con))
664
838
  {
665
839
    con->packet_number= 0;
690
864
  size_t offset= 0;
691
865
  size_t size= 0;
692
866
 
 
867
  if (con == NULL)
 
868
  {
 
869
    return NULL;
 
870
  }
 
871
 
 
872
  drizzle_return_t unused;
 
873
  if (ret_ptr == NULL)
 
874
  {
 
875
    ret_ptr= &unused;
 
876
  }
 
877
 
 
878
  size_t total_unused;
 
879
  if (total == NULL)
 
880
  {
 
881
    total= &total_unused;
 
882
  }
 
883
 
693
884
  uint8_t *command_data=
694
885
    static_cast<uint8_t *>(drizzle_con_command_read(con, command, &offset,
695
886
                                                    &size, total, ret_ptr));
696
887
  if (*ret_ptr != DRIZZLE_RETURN_OK)
 
888
  {
697
889
    return NULL;
 
890
  }
698
891
 
699
892
  if (command_data == NULL)
700
893
  {
714
907
    command_data= (uint8_t *)drizzle_con_command_read(con, command, &offset,
715
908
                                                      &size, total, ret_ptr);
716
909
    if (*ret_ptr != DRIZZLE_RETURN_OK)
 
910
    {
717
911
      return NULL;
 
912
    }
718
913
 
719
914
    memcpy(con->command_buffer + offset, command_data, size);
720
915
  }
770
965
  struct addrinfo ai;
771
966
  int ret;
772
967
 
 
968
  if (con == NULL)
 
969
  {
 
970
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
971
  }
 
972
 
773
973
  drizzle_log_debug(con->drizzle, "drizzle_state_addrinfo");
774
974
 
775
975
  switch (con->socket_type)
784
984
    }
785
985
 
786
986
    if (tcp->port != 0)
 
987
    {
787
988
      snprintf(port, NI_MAXSERV, "%u", tcp->port);
 
989
    }
788
990
    else if (con->options & DRIZZLE_CON_MYSQL)
 
991
    {
789
992
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);
 
993
    }
790
994
    else
 
995
    {
791
996
      snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
 
997
    }
792
998
    port[NI_MAXSERV-1]= 0;
793
999
 
794
1000
    memset(&ai, 0, sizeof(ai));