← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/drizzle.cc

  • Committer: Brian Aker
  • Date: 2011-11-26 23:14:59 UTC
  • mto: This revision was merged to the branch mainline in revision 2465.
  • Revision ID: brian@tangent.org-20111126231459-pa9i3arizevf0vlr
Remove con from being passed object.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/drizzle.cc
107
107
  {
108
108
    return NULL;
109
109
  }
110
 
  drizzle->options.is_allocated= true;
111
110
 
112
111
  /* @todo remove this default free flag with new API. */
113
112
  drizzle->options.is_free_objects= true;
145
144
    return NULL;
146
145
  }
147
146
 
148
 
  bool cache_state= drizzle->options.is_allocated;
149
 
  drizzle->options= source->options;
150
 
  drizzle->options.is_allocated= cache_state;
151
 
 
152
147
  for (drizzle_con_st* con= source->con_list; con != NULL; con= con->next)
153
148
  {
154
 
    if (drizzle_con_clone(drizzle, NULL, con) == NULL)
 
149
    if (drizzle_con_clone(drizzle, con) == NULL)
155
150
    {
156
151
      drizzle_free(drizzle);
157
152
      return NULL;
181
176
 
182
177
  free(drizzle->pfds);
183
178
 
184
 
  if (drizzle->options.is_allocated)
185
 
  {
186
 
    delete drizzle;
187
 
  }
 
179
  delete drizzle;
188
180
#if defined(_WIN32)
189
181
  /* if it is MS windows, invoke WSACleanup() at the end*/
190
182
  WSACleanup();
283
275
  drizzle->event_watch_context= context;
284
276
}
285
277
 
286
 
drizzle_con_st *drizzle_con_create(drizzle_st *drizzle, drizzle_con_st *con)
 
278
drizzle_con_st *drizzle_con_create(drizzle_st *drizzle)
287
279
{
 
280
  if (drizzle == NULL)
 
281
  {
 
282
    return NULL;
 
283
  }
 
284
 
 
285
  drizzle_con_st *con= new (std::nothrow) drizzle_con_st;
 
286
 
288
287
  if (con == NULL)
289
288
  {
290
 
    con= new (std::nothrow) drizzle_con_st;
291
 
    con->_options.is_allocated= true;
292
 
  }
293
 
  else
294
 
  {
295
 
    con->options= 0;
 
289
    return NULL;
296
290
  }
297
291
 
298
292
  if (drizzle->con_list != NULL)
 
293
  {
299
294
    drizzle->con_list->prev= con;
 
295
  }
300
296
 
301
297
  con->next= drizzle->con_list;
302
298
  con->prev= NULL;
351
347
  return con;
352
348
}
353
349
 
354
 
drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *con,
355
 
                                  const drizzle_con_st *from)
 
350
drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *source)
356
351
{
357
 
  con= drizzle_con_create(drizzle, con);
 
352
  drizzle_con_st *con= drizzle_con_create(drizzle);
358
353
  if (con == NULL)
359
354
  {
360
355
    return NULL;
361
356
  }
362
357
 
363
358
  /* Clear "operational" options such as IO status. */
364
 
  con->options|= (from->options & ~(DRIZZLE_CON_ALLOCATED|DRIZZLE_CON_READY|
 
359
  con->options|= (source->options & ~(DRIZZLE_CON_ALLOCATED|DRIZZLE_CON_READY|
365
360
                  DRIZZLE_CON_NO_RESULT_READ|DRIZZLE_CON_IO_READY|
366
361
                  DRIZZLE_CON_LISTEN));
367
 
  con->backlog= from->backlog;
368
 
  strcpy(con->schema, from->schema);
369
 
  strcpy(con->password, from->password);
370
 
  strcpy(con->user, from->user);
 
362
  con->backlog= source->backlog;
 
363
  strcpy(con->schema, source->schema);
 
364
  strcpy(con->password, source->password);
 
365
  strcpy(con->user, source->user);
371
366
 
372
 
  switch (from->socket_type)
 
367
  switch (source->socket_type)
373
368
  {
374
369
  case DRIZZLE_CON_SOCKET_TCP:
375
 
    drizzle_con_set_tcp(con, from->socket.tcp.host, from->socket.tcp.port);
 
370
    drizzle_con_set_tcp(con, source->socket.tcp.host, source->socket.tcp.port);
376
371
    break;
377
372
 
378
373
  case DRIZZLE_CON_SOCKET_UDS:
379
 
    drizzle_con_set_uds(con, from->socket.uds.sockaddr.sun_path);
 
374
    drizzle_con_set_uds(con, source->socket.uds.sockaddr.sun_path);
380
375
    break;
381
376
  }
382
377
 
420
415
  }
421
416
  con->drizzle->con_count--;
422
417
 
423
 
  if (con->_options.is_allocated)
424
 
  {
425
 
    delete con;
426
 
  }
 
418
  delete con;
427
419
}
428
420
 
429
421
void drizzle_con_free_all(drizzle_st *drizzle)
557
549
 * Client Definitions
558
550
 */
559
551
 
560
 
drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle, drizzle_con_st *con,
 
552
drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle,
561
553
                                    const char *host, in_port_t port,
562
554
                                    const char *user, const char *password,
563
555
                                    const char *db,
564
556
                                    drizzle_con_options_t options)
565
557
{
566
 
  con= drizzle_con_create(drizzle, con);
 
558
  drizzle_con_st *con= drizzle_con_create(drizzle);
567
559
  if (con == NULL)
568
560
  {
569
561
    return NULL;
577
569
  return con;
578
570
}
579
571
 
580
 
drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle, drizzle_con_st *con,
 
572
drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle,
581
573
                                    const char *uds, const char *user,
582
574
                                    const char *password, const char *db,
583
575
                                    drizzle_con_options_t options)
584
576
{
585
 
  con= drizzle_con_create(drizzle, con);
 
577
  drizzle_con_st *con= drizzle_con_create(drizzle);
586
578
  if (con == NULL)
587
579
  {
588
580
    return NULL;
601
593
 */
602
594
 
603
595
drizzle_con_st *drizzle_con_add_tcp_listen(drizzle_st *drizzle,
604
 
                                           drizzle_con_st *con,
605
596
                                           const char *host, in_port_t port,
606
597
                                           int backlog,
607
598
                                           drizzle_con_options_t options)
608
599
{
609
 
  con= drizzle_con_create(drizzle, con);
 
600
  drizzle_con_st *con= drizzle_con_create(drizzle);
610
601
  if (con == NULL)
611
602
  {
612
603
    return NULL;
620
611
}
621
612
 
622
613
drizzle_con_st *drizzle_con_add_uds_listen(drizzle_st *drizzle,
623
 
                                           drizzle_con_st *con,
624
614
                                           const char *uds, int backlog,
625
615
                                           drizzle_con_options_t options)
626
616
{
627
 
  con= drizzle_con_create(drizzle, con);
 
617
  drizzle_con_st *con= drizzle_con_create(drizzle);
628
618
  if (con == NULL)
629
619
  {
630
620
    return NULL;
637
627
  return con;
638
628
}
639
629
 
640
 
drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle, drizzle_con_st *con,
 
630
drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle,
641
631
                                   drizzle_return_t *ret_ptr)
642
632
{
 
633
  drizzle_return_t unused;
 
634
  if (ret_ptr == NULL)
 
635
  {
 
636
    ret_ptr= &unused;
 
637
  }
 
638
 
643
639
  while (1)
644
640
  {
645
641
    if (drizzle_con_st* ready= drizzle_con_ready_listen(drizzle))
646
642
    {
647
643
      int fd= accept(ready->fd, NULL, NULL);
648
644
 
649
 
      con= drizzle_con_create(drizzle, con);
 
645
      drizzle_con_st *con= drizzle_con_create(drizzle);
650
646
      if (con == NULL)
651
647
      {
652
648
        (void)closesocket(fd);
677
673
    for (drizzle_con_st* ready= drizzle->con_list; ready != NULL; ready= ready->next)
678
674
    {
679
675
      if (ready->options & DRIZZLE_CON_LISTEN)
 
676
      {
680
677
        drizzle_con_set_events(ready, POLLIN);
 
678
      }
681
679
    }
682
680
 
683
681
    *ret_ptr= drizzle_con_wait(drizzle);
684
682
    if (*ret_ptr != DRIZZLE_RETURN_OK)
 
683
    {
685
684
      return NULL;
 
685
    }
686
686
  }
687
687
}
688
688
 
693
693
void drizzle_set_error(drizzle_st *drizzle, const char *function,
694
694
                       const char *format, ...)
695
695
{
 
696
  if (drizzle == NULL)
 
697
  {
 
698
    return;
 
699
  }
696
700
  char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
697
701
 
698
702
  size_t size= strlen(function);
737
741
{
738
742
  char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
739
743
 
 
744
  if (drizzle == NULL)
 
745
  {
 
746
    return;
 
747
  }
 
748
 
740
749
  if (drizzle->log_fn == NULL)
741
750
  {
742
751
    printf("%5s: ", drizzle_verbose_name(verbose));