~drizzle-trunk/drizzle/development : revision 2462

267

}

268

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

return result;

589

return NULL;

495

590

}

496

591

497

592

*ret_ptr= drizzle_con_connect(con);

498

593

if (*ret_ptr != DRIZZLE_RETURN_OK)

499

594

{

500

return result;

595

return NULL;

501

596

}

502

597

}

503

598

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

{

516

611

drizzle_set_error(con->drizzle, "drizzle_command_write", "result struct already in use");

517

612

*ret_ptr= DRIZZLE_RETURN_INTERNAL_ERROR;

518

return result;

613

return NULL;

519

614

}

520

615

}

521

616

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

void drizzle_con_set_protocol_version(drizzle_con_st *con,

587

uint8_t protocol_version)

700

void drizzle_con_set_protocol_version(drizzle_con_st *con, uint8_t protocol_version)

588

701

{

702

if (con == NULL)

703

{

704

return;

705

}

706

589

707

con->protocol_version= protocol_version;

590

708

}

591

709

592

710

void drizzle_con_set_server_version(drizzle_con_st *con,

593

711

const char *server_version)

594

712

{

713

if (con == NULL)

714

{

715

return;

716

}

717

595

718

if (server_version == NULL)

719

{

596

720

con->server_version[0]= 0;

721

}

597

722

else

598

723

{

599

724

strncpy(con->server_version, server_version,

604

729

605

730

void drizzle_con_set_thread_id(drizzle_con_st *con, uint32_t thread_id)

606

731

{

732

if (con == NULL)

733

{

734

return;

735

}

736

607

737

con->thread_id= thread_id;

608

738

}

609

739

610

740

void drizzle_con_set_scramble(drizzle_con_st *con, const uint8_t *scramble)

611

741

{

742

if (con == NULL)

743

{

744

return;

745

}

746

612

747

if (scramble == NULL)

748

{

613

749

con->scramble= NULL;

750

}

614

751

else

615

752

{

616

753

con->scramble= con->scramble_buffer;

621

758

void drizzle_con_set_capabilities(drizzle_con_st *con,

622

759

int capabilities)

623

760

{

761

if (con == NULL)

762

{

763

return;

764

}

765

624

766

con->capabilities= capabilities;

625

767

}

626

768

627

769

void drizzle_con_set_charset(drizzle_con_st *con, drizzle_charset_t charset)

628

770

{

771

if (con == NULL)

772

{

773

return;

774

}

775

629

776

con->charset= charset;

630

777

}

631

778

632

779

void drizzle_con_set_status(drizzle_con_st *con, drizzle_con_status_t status)

633

780

{

781

if (con == NULL)

782

{

783

return;

784

}

785

634

786

con->status= status;

635

787

}

636

788

637

789

void drizzle_con_set_max_packet_size(drizzle_con_st *con,

638

790

uint32_t max_packet_size)

639

791

{

792

if (con == NULL)

793

{

794

return;

795

}

796

640

797

con->max_packet_size= max_packet_size;

641

798

}

642

799

643

800

void drizzle_con_copy_handshake(drizzle_con_st *con, drizzle_con_st *from)

644

801

{

802

if (con == NULL)

803

{

804

return;

805

}

806

645

807

drizzle_con_set_auth(con, from->user, NULL);

646

808

drizzle_con_set_scramble(con, from->scramble);

647

drizzle_con_set_db(con, from->db);

809

drizzle_con_set_db(con, from->schema);

648

810

drizzle_con_set_protocol_version(con, from->protocol_version);

649

811

drizzle_con_set_server_version(con, from->server_version);

650

812

drizzle_con_set_thread_id(con, from->thread_id);

660

822

size_t *size, size_t *total,

661

823

drizzle_return_t *ret_ptr)

662

824

{

825

if (con == NULL)

826

{

827

return NULL;

828

}

829

830

drizzle_return_t unused;

831

if (ret_ptr == NULL)

832

{

833

ret_ptr= &unused;

834

}

835

663

836

if (drizzle_state_none(con))

664

837

{

665

838

con->packet_number= 0;

690

863

size_t offset= 0;

691

864

size_t size= 0;

692

865

866

if (con == NULL)

867

{

868

return NULL;

869

}

870

871

drizzle_return_t unused;

872

if (ret_ptr == NULL)

873

{

874

ret_ptr= &unused;

875

}

876

877

size_t total_unused;

878

if (total == NULL)

879

{

880

total= &total_unused;

881

}

882

693

883

uint8_t *command_data=

694

884

static_cast<uint8_t *>(drizzle_con_command_read(con, command, &offset,

695

885

&size, total, ret_ptr));

696

886

if (*ret_ptr != DRIZZLE_RETURN_OK)

887

{

697

888

return NULL;

889

}

698

890

699

891

if (command_data == NULL)

700

892

{

704

896

705

897

if (con->command_buffer == NULL)

706

898

{

707

con->command_buffer= new uint8_t[(*total) + 1];

899

con->command_buffer= new (std::nothrow) uint8_t[(*total) + 1];

900

901

if (con->command_buffer == NULL)

902

{

903

*total= 0;

904

*ret_ptr= DRIZZLE_RETURN_MEMORY;

905

return NULL;

906

}

708

907

}

709

908

710

909

memcpy(con->command_buffer + offset, command_data, size);

714

913

command_data= (uint8_t *)drizzle_con_command_read(con, command, &offset,

715

914

&size, total, ret_ptr);

716

915

if (*ret_ptr != DRIZZLE_RETURN_OK)

916

{

717

917

return NULL;

918

}

718

919

719

920

memcpy(con->command_buffer + offset, command_data, size);

720

921

}

770

971

struct addrinfo ai;

771

972

int ret;

772

973

974

if (con == NULL)

975

{

976

return DRIZZLE_RETURN_INVALID_ARGUMENT;

977

}

978

773

979

drizzle_log_debug(con->drizzle, "drizzle_state_addrinfo");

774

980

775

981

switch (con->socket_type)

784

990

}

785

991

786

992

if (tcp->port != 0)

993

{

787

994

snprintf(port, NI_MAXSERV, "%u", tcp->port);

995

}

788

996

else if (con->options & DRIZZLE_CON_MYSQL)

997

{

789

998

snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT_MYSQL);

999

}

790

1000

else

1001

{

791

1002

snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);

1003

}

792

1004

port[NI_MAXSERV-1]= 0;

793

1005

794

1006

memset(&ai, 0, sizeof(ai));

962

1174

if (ret != DRIZZLE_RETURN_OK)

963

1175

return ret;

964

1176

965

if (con->drizzle->options & DRIZZLE_NON_BLOCKING)

1177

if (con->drizzle->options.is_non_blocking)

1178

{

966

1179

return DRIZZLE_RETURN_IO_WAIT;

1180

}

967

1181

968

1182

ret= drizzle_con_wait(con->drizzle);

969

1183

if (ret != DRIZZLE_RETURN_OK)

1184

{

970

1185

return ret;

1186

}

971

1187

}

972

1188

}

973

1189

986

1202

}

987

1203

988

1204

if ((con->revents & POLLIN) == 0 &&

989

(con->drizzle->options & DRIZZLE_NON_BLOCKING))

1205

(con->drizzle->options.is_non_blocking))

990

1206

{

991

1207

/* non-blocking mode: return IO_WAIT instead of attempting to read. This

992

1208

* avoids reading immediately after writing a command, which typically

1059

1275

if (ret != DRIZZLE_RETURN_OK)

1060

1276

return ret;

1061

1277

1062

if (con->drizzle->options & DRIZZLE_NON_BLOCKING)

1278

if (con->drizzle->options.is_non_blocking)

1279

{

1063

1280

return DRIZZLE_RETURN_IO_WAIT;

1281

}

1064

1282

1065

1283

ret= drizzle_con_wait(con->drizzle);

1066

1284

if (ret != DRIZZLE_RETURN_OK)

1285

{

1067

1286

return ret;

1287

}

1068

1288

1069

1289

continue;

1070

1290

}

1162

1382

{

1163

1383

ret= drizzle_con_set_events(con, POLLOUT);

1164

1384

if (ret != DRIZZLE_RETURN_OK)

1385

{

1165

1386

return ret;

1387

}

1166

1388

1167

if (con->drizzle->options & DRIZZLE_NON_BLOCKING)

1389

if (con->drizzle->options.is_non_blocking)

1390

{

1168

1391

return DRIZZLE_RETURN_IO_WAIT;

1392

}

1169

1393

1170

1394

ret= drizzle_con_wait(con->drizzle);

1171

1395

if (ret != DRIZZLE_RETURN_OK)

1396

{

1172

1397

return ret;

1398

}

1173

1399

1174

1400

continue;

1175

1401

}

1176

1402

else if (errno == EINTR)

1403

{

1177

1404

continue;

1405

}

1178

1406

else if (errno == EPIPE || errno == ECONNRESET)

1179

1407

{

1180

1408

drizzle_set_error(con->drizzle, "drizzle_state_write",