~ubuntu-branches/ubuntu/quantal/curl/quantal-security : revision 70

1

#ifndef HEADER_CURL_URLDATA_H

2

#define HEADER_CURL_URLDATA_H

3

/***************************************************************************

4

* _ _ ____ _

5

* Project ___| | | | _ \| |

6

* / __| | | | |_) | |

7

* | (__| |_| | _ <| |___

8

* \___|\___/|_| \_\_____|

9

*

10

11

*

12

* This software is licensed as described in the file COPYING, which

13

* you should have received as part of this distribution. The terms

14

* are also available at http://curl.haxx.se/docs/copyright.html.

15

*

16

* You may opt to use, copy, modify, merge, publish, distribute and/or sell

17

* copies of the Software, and permit persons to whom the Software is

18

* furnished to do so, under the terms of the COPYING file.

19

*

20

* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

21

* KIND, either express or implied.

22

*

23

***************************************************************************/

24

25

/* This file is for lib internal stuff */

26

27

#include "setup.h"

28

29

#define PORT_FTP 21

30

#define PORT_FTPS 990

31

#define PORT_TELNET 23

32

#define PORT_HTTP 80

33

#define PORT_HTTPS 443

34

#define PORT_DICT 2628

35

#define PORT_LDAP 389

36

#define PORT_LDAPS 636

37

#define PORT_TFTP 69

38

#define PORT_SSH 22

39

#define PORT_IMAP 143

40

#define PORT_IMAPS 993

41

#define PORT_POP3 110

42

#define PORT_POP3S 995

43

#define PORT_SMTP 25

44

#define PORT_SMTPS 465 /* sometimes called SSMTP */

45

#define PORT_RTSP 554

46

#define PORT_RTMP 1935

47

#define PORT_RTMPT PORT_HTTP

48

#define PORT_RTMPS PORT_HTTPS

49

#define PORT_GOPHER 70

50

51

#define DICT_MATCH "/MATCH:"

52

#define DICT_MATCH2 "/M:"

53

#define DICT_MATCH3 "/FIND:"

54

#define DICT_DEFINE "/DEFINE:"

55

#define DICT_DEFINE2 "/D:"

56

#define DICT_DEFINE3 "/LOOKUP:"

57

58

#define CURL_DEFAULT_USER "anonymous"

59

#define CURL_DEFAULT_PASSWORD "ftp@example.com"

60

61

/* length of longest IPv6 address string including the trailing null */

62

#define MAX_IPADR_LEN sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")

63

64

/* Default FTP/IMAP etc response timeout in milliseconds.

65

Symbian OS panics when given a timeout much greater than 1/2 hour.

66

*/

67

#define RESP_TIMEOUT (1800*1000)

68

69

#include "cookie.h"

70

#include "formdata.h"

71

72

#ifdef USE_SSLEAY

73

#ifdef USE_OPENSSL

74

#include <openssl/rsa.h>

75

#include <openssl/crypto.h>

76

#include <openssl/x509.h>

77

#include <openssl/pem.h>

78

#include <openssl/ssl.h>

79

#include <openssl/err.h>

80

#ifdef HAVE_OPENSSL_ENGINE_H

81

#include <openssl/engine.h>

82

#endif

83

#ifdef HAVE_OPENSSL_PKCS12_H

84

#include <openssl/pkcs12.h>

85

#endif

86

#else /* SSLeay-style includes */

87

#include <rsa.h>

88

#include <crypto.h>

89

#include <x509.h>

90

#include <pem.h>

91

#include <ssl.h>

92

#include <err.h>

93

#ifdef HAVE_OPENSSL_ENGINE_H

94

#include <engine.h>

95

#endif

96

#ifdef HAVE_OPENSSL_PKCS12_H

97

#include <pkcs12.h>

98

#endif

99

#endif /* USE_OPENSSL */

100

#ifdef USE_GNUTLS

101

#error Configuration error; cannot use GnuTLS *and* OpenSSL.

102

#endif

103

#endif /* USE_SSLEAY */

104

105

#ifdef USE_GNUTLS

106

#include <gnutls/gnutls.h>

107

#endif

108

109

#ifdef USE_POLARSSL

110

#include <polarssl/havege.h>

111

#include <polarssl/ssl.h>

112

#endif

113

114

#ifdef USE_CYASSL

115

#undef OCSP_REQUEST /* avoid cyassl/openssl/ssl.h clash with wincrypt.h */

116

#undef OCSP_RESPONSE /* avoid cyassl/openssl/ssl.h clash with wincrypt.h */

117

#include <cyassl/openssl/ssl.h>

118

#endif

119

120

#ifdef USE_NSS

121

#include <nspr.h>

122

#include <pk11pub.h>

123

#endif

124

125

#ifdef USE_QSOSSL

126

#include <qsossl.h>

127

#endif

128

129

#ifdef USE_AXTLS

130

#include <axTLS/ssl.h>

131

#undef malloc

132

#undef calloc

133

#undef realloc

134

#endif /* USE_AXTLS */

135

136

#ifdef USE_SCHANNEL

137

#include "curl_sspi.h"

138

#include <schnlsp.h>

139

#include <schannel.h>

140

#endif

141

142

#ifdef USE_DARWINSSL

143

#include <Security/Security.h>

144

/* For some reason, when building for iOS, the omnibus header above does

145

* not include SecureTransport.h as of iOS SDK 5.1. */

146

#include <Security/SecureTransport.h>

147

#endif

148

149

#ifdef HAVE_NETINET_IN_H

150

#include <netinet/in.h>

151

#endif

152

153

#include "timeval.h"

154

155

#ifdef HAVE_ZLIB_H

156

#include <zlib.h> /* for content-encoding */

157

#ifdef __SYMBIAN32__

158

/* zlib pollutes the namespace with this definition */

159

#undef WIN32

160

#endif

161

#endif

162

163

#include <curl/curl.h>

164

165

#include "http_chunks.h" /* for the structs and enum stuff */

166

#include "hostip.h"

167

#include "hash.h"

168

#include "splay.h"

169

170

#include "imap.h"

171

#include "pop3.h"

172

#include "smtp.h"

173

#include "ftp.h"

174

#include "file.h"

175

#include "ssh.h"

176

#include "http.h"

177

#include "rtsp.h"

178

#include "wildcard.h"

179

180

#ifdef HAVE_GSSAPI

181

# ifdef HAVE_GSSGNU

182

# include <gss.h>

183

# elif defined HAVE_GSSMIT

184

# include <gssapi/gssapi.h>

185

# include <gssapi/gssapi_generic.h>

186

# else

187

# include <gssapi.h>

188

# endif

189

#endif

190

191

#ifdef HAVE_LIBSSH2_H

192

#include <libssh2.h>

193

#include <libssh2_sftp.h>

194

#endif /* HAVE_LIBSSH2_H */

195

196

/* Download buffer size, keep it fairly big for speed reasons */

197

#undef BUFSIZE

198

#define BUFSIZE CURL_MAX_WRITE_SIZE

199

200

/* Initial size of the buffer to store headers in, it'll be enlarged in case

201

of need. */

202

#define HEADERSIZE 256

203

204

#define CURLEASY_MAGIC_NUMBER 0xc0dedbadU

205

206

/* Some convenience macros to get the larger/smaller value out of two given.

207

We prefix with CURL to prevent name collisions. */

208

#define CURLMAX(x,y) ((x)>(y)?(x):(y))

209

#define CURLMIN(x,y) ((x)<(y)?(x):(y))

210

211

212

#if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)

213

/* Types needed for krb4/5-ftp connections */

214

struct krb4buffer {

215

void *data;

216

size_t size;

217

size_t index;

218

int eof_flag;

219

};

220

221

enum protection_level {

222

PROT_NONE, /* first in list */

223

PROT_CLEAR,

224

PROT_SAFE,

225

PROT_CONFIDENTIAL,

226

PROT_PRIVATE,

227

PROT_CMD,

228

PROT_LAST /* last in list */

229

};

230

#endif

231

232

#ifdef USE_SCHANNEL

233

/* Structs to store Schannel handles */

234

struct curl_schannel_cred {

235

CredHandle cred_handle;

236

TimeStamp time_stamp;

237

};

238

239

struct curl_schannel_ctxt {

240

CtxtHandle ctxt_handle;

241

TimeStamp time_stamp;

242

};

243

#endif

244

245

/* enum for the nonblocking SSL connection state machine */

246

typedef enum {

247

ssl_connect_1,

248

ssl_connect_2,

249

ssl_connect_2_reading,

250

ssl_connect_2_writing,

251

ssl_connect_3,

252

ssl_connect_done

253

} ssl_connect_state;

254

255

typedef enum {

256

ssl_connection_none,

257

ssl_connection_negotiating,

258

ssl_connection_complete

259

} ssl_connection_state;

260

261

/* struct for data related to each SSL connection */

262

struct ssl_connect_data {

263

/* Use ssl encrypted communications TRUE/FALSE, not necessarily using it atm

264

but at least asked to or meaning to use it. See 'state' for the exact

265

current state of the connection. */

266

bool use;

267

ssl_connection_state state;

268

#ifdef USE_SSLEAY

269

/* these ones requires specific SSL-types */

270

SSL_CTX* ctx;

271

SSL* handle;

272

X509* server_cert;

273

ssl_connect_state connecting_state;

274

#endif /* USE_SSLEAY */

275

#ifdef USE_GNUTLS

276

gnutls_session session;

277

gnutls_certificate_credentials cred;

278

#ifdef USE_TLS_SRP

279

gnutls_srp_client_credentials srp_client_cred;

280

#endif

281

ssl_connect_state connecting_state;

282

#endif /* USE_GNUTLS */

283

#ifdef USE_POLARSSL

284

havege_state hs;

285

ssl_context ssl;

286

ssl_session ssn;

287

int server_fd;

288

x509_cert cacert;

289

x509_cert clicert;

290

x509_crl crl;

291

rsa_context rsa;

292

ssl_connect_state connecting_state;

293

#endif /* USE_POLARSSL */

294

#ifdef USE_CYASSL

295

SSL_CTX* ctx;

296

SSL* handle;

297

ssl_connect_state connecting_state;

298

#endif /* USE_CYASSL */

299

#ifdef USE_NSS

300

PRFileDesc *handle;

301

char *client_nickname;

302

struct SessionHandle *data;

303

struct curl_llist *obj_list;

304

PK11GenericObject *obj_clicert;

305

#endif /* USE_NSS */

306

#ifdef USE_QSOSSL

307

SSLHandle *handle;

308

#endif /* USE_QSOSSL */

309

#ifdef USE_AXTLS

310

SSL_CTX* ssl_ctx;

311

SSL* ssl;

312

#endif /* USE_AXTLS */

313

#ifdef USE_SCHANNEL

314

struct curl_schannel_cred *cred;

315

struct curl_schannel_ctxt *ctxt;

316

SecPkgContext_StreamSizes stream_sizes;

317

ssl_connect_state connecting_state;

318

size_t encdata_length, decdata_length;

319

size_t encdata_offset, decdata_offset;

320

unsigned char *encdata_buffer, *decdata_buffer;

321

unsigned long req_flags, ret_flags;

322

#endif /* USE_SCHANNEL */

323

#ifdef USE_DARWINSSL

324

SSLContextRef ssl_ctx;

325

curl_socket_t ssl_sockfd;

326

ssl_connect_state connecting_state;

327

bool ssl_direction; /* true if writing, false if reading */

328

#endif /* USE_DARWINSSL */

329

};

330

331

struct ssl_config_data {

332

long version; /* what version the client wants to use */

333

long certverifyresult; /* result from the certificate verification */

334

long verifypeer; /* set TRUE if this is desired */

335

long verifyhost; /* 0: no verify

336

1: check that CN exists

337

2: CN must match hostname */

338

char *CApath; /* certificate dir (doesn't work on windows) */

339

char *CAfile; /* certificate to verify peer against */

340

const char *CRLfile; /* CRL to check certificate revocation */

341

const char *issuercert;/* optional issuer certificate filename */

342

char *random_file; /* path to file containing "random" data */

343

char *egdsocket; /* path to file containing the EGD daemon socket */

344

char *cipher_list; /* list of ciphers to use */

345

size_t max_ssl_sessions; /* SSL session id cache size */

346

curl_ssl_ctx_callback fsslctx; /* function to initialize ssl ctx */

347

void *fsslctxp; /* parameter for call back */

348

bool sessionid; /* cache session IDs or not */

349

bool certinfo; /* gather lots of certificate info */

350

351

#ifdef USE_TLS_SRP

352

char *username; /* TLS username (for, e.g., SRP) */

353

char *password; /* TLS password (for, e.g., SRP) */

354

enum CURL_TLSAUTH authtype; /* TLS authentication type (default SRP) */

355

#endif

356

};

357

358

/* information stored about one single SSL session */

359

struct curl_ssl_session {

360

char *name; /* host name for which this ID was used */

361

void *sessionid; /* as returned from the SSL layer */

362

size_t idsize; /* if known, otherwise 0 */

363

long age; /* just a number, the higher the more recent */

364

unsigned short remote_port; /* remote port to connect to */

365

struct ssl_config_data ssl_config; /* setup for this session */

366

};

367

368

/* Struct used for Digest challenge-response authentication */

369

struct digestdata {

370

char *nonce;

371

char *cnonce;

372

char *realm;

373

int algo;

374

bool stale; /* set true for re-negotiation */

375

char *opaque;

376

char *qop;

377

char *algorithm;

378

int nc; /* nounce count */

379

};

380

381

typedef enum {

382

NTLMSTATE_NONE,

383

NTLMSTATE_TYPE1,

384

NTLMSTATE_TYPE2,

385

NTLMSTATE_TYPE3,

386

NTLMSTATE_LAST

387

} curlntlm;

388

389

#ifdef USE_WINDOWS_SSPI

390

#include "curl_sspi.h"

391

#endif

392

393

#if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)

394

#include <iconv.h>

395

#endif

396

397

/* Struct used for NTLM challenge-response authentication */

398

struct ntlmdata {

399

curlntlm state;

400

#ifdef USE_WINDOWS_SSPI

401

CredHandle handle;

402

CtxtHandle c_handle;

403

SEC_WINNT_AUTH_IDENTITY identity;

404

SEC_WINNT_AUTH_IDENTITY *p_identity;

405

int has_handles;

406

void *type_2;

407

unsigned long n_type_2;

408

#else

409

unsigned int flags;

410

unsigned char nonce[8];

411

#endif

412

};

413

414

#ifdef USE_HTTP_NEGOTIATE

415

struct negotiatedata {

416

/* when doing Negotiate we first need to receive an auth token and then we

417

need to send our header */

418

enum { GSS_AUTHNONE, GSS_AUTHRECV, GSS_AUTHSENT } state;

419

bool gss; /* Whether we're processing GSS-Negotiate or Negotiate */

420

const char* protocol; /* "GSS-Negotiate" or "Negotiate" */

421

#ifdef HAVE_GSSAPI

422

OM_uint32 status;

423

gss_ctx_id_t context;

424

gss_name_t server_name;

425

gss_buffer_desc output_token;

426

#else

427

#ifdef USE_WINDOWS_SSPI

428

DWORD status;

429

CtxtHandle *context;

430

CredHandle *credentials;

431

char server_name[1024];

432

size_t max_token_length;

433

BYTE *output_token;

434

size_t output_token_length;

435

#endif

436

#endif

437

};

438

#endif

439

440

441

/*

442

* Boolean values that concerns this connection.

443

*/

444

struct ConnectBits {

445

bool close; /* if set, we close the connection after this request */

446

bool reuse; /* if set, this is a re-used connection */

447

bool proxy; /* if set, this transfer is done through a proxy - any type */

448

bool httpproxy; /* if set, this transfer is done through a http proxy */

449

bool user_passwd; /* do we use user+password for this connection? */

450

bool proxy_user_passwd; /* user+password for the proxy? */

451

bool ipv6_ip; /* we communicate with a remote site specified with pure IPv6

452

IP address */

453

bool ipv6; /* we communicate with a site using an IPv6 address */

454

455

bool do_more; /* this is set TRUE if the ->curl_do_more() function is

456

supposed to be called, after ->curl_do() */

457

bool tcpconnect[2]; /* the TCP layer (or similar) is connected, this is set

458

the first time on the first connect function call */

459

bool protoconnstart;/* the protocol layer has STARTED its operation after

460

the TCP layer connect */

461

462

bool retry; /* this connection is about to get closed and then

463

re-attempted at another connection. */

464

bool tunnel_proxy; /* if CONNECT is used to "tunnel" through the proxy.

465

This is implicit when SSL-protocols are used through

466

proxies, but can also be enabled explicitly by

467

apps */

468

bool authneg; /* TRUE when the auth phase has started, which means

469

that we are creating a request with an auth header,

470

but it is not the final request in the auth

471

negotiation. */

472

bool rewindaftersend;/* TRUE when the sending couldn't be stopped even

473

though it will be discarded. When the whole send

474

operation is done, we must call the data rewind

475

callback. */

476

bool ftp_use_epsv; /* As set with CURLOPT_FTP_USE_EPSV, but if we find out

477

EPSV doesn't work we disable it for the forthcoming

478

requests */

479

480

bool ftp_use_eprt; /* As set with CURLOPT_FTP_USE_EPRT, but if we find out

481

EPRT doesn't work we disable it for the forthcoming

482

requests */

483

bool netrc; /* name+password provided by netrc */

484

bool userpwd_in_url; /* name+password found in url */

485

486

bool done; /* set to FALSE when Curl_do() is called and set to TRUE

487

when Curl_done() is called, to prevent Curl_done() to

488

get invoked twice when the multi interface is

489

used. */

490

bool stream_was_rewound; /* Indicates that the stream was rewound after a

491

request read past the end of its response byte

492

boundary */

493

bool proxy_connect_closed; /* set true if a proxy disconnected the

494

connection in a CONNECT request with auth, so

495

that libcurl should reconnect and continue. */

496

bool bound; /* set true if bind() has already been done on this socket/

497

connection */

498

bool type_set; /* type= was used in the URL */

499

};

500

501

struct hostname {

502

char *rawalloc; /* allocated "raw" version of the name */

503

char *encalloc; /* allocated IDN-encoded version of the name */

504

char *name; /* name to use internally, might be encoded, might be raw */

505

const char *dispname; /* name to display, as 'name' might be encoded */

506

};

507

508

/*

509

* Flags on the keepon member of the Curl_transfer_keeper

510

*/

511

512

#define KEEP_NONE 0

513

#define KEEP_RECV (1<<0) /* there is or may be data to read */

514

#define KEEP_SEND (1<<1) /* there is or may be data to write */

515

#define KEEP_RECV_HOLD (1<<2) /* when set, no reading should be done but there

516

might still be data to read */

517

#define KEEP_SEND_HOLD (1<<3) /* when set, no writing should be done but there

518

might still be data to write */

519

#define KEEP_RECV_PAUSE (1<<4) /* reading is paused */

520

#define KEEP_SEND_PAUSE (1<<5) /* writing is paused */

521

522

#define KEEP_RECVBITS (KEEP_RECV | KEEP_RECV_HOLD | KEEP_RECV_PAUSE)

523

#define KEEP_SENDBITS (KEEP_SEND | KEEP_SEND_HOLD | KEEP_SEND_PAUSE)

524

525

526

#ifdef HAVE_LIBZ

527

typedef enum {

528

ZLIB_UNINIT, /* uninitialized */

529

ZLIB_INIT, /* initialized */

530

ZLIB_GZIP_HEADER, /* reading gzip header */

531

ZLIB_GZIP_INFLATING, /* inflating gzip stream */

532

ZLIB_INIT_GZIP /* initialized in transparent gzip mode */

533

} zlibInitState;

534

#endif

535

536

#ifdef CURLRES_ASYNCH

537

struct Curl_async {

538

char *hostname;

539

int port;

540

struct Curl_dns_entry *dns;

541

bool done; /* set TRUE when the lookup is complete */

542

int status; /* if done is TRUE, this is the status from the callback */

543

void *os_specific; /* 'struct thread_data' for Windows */

544

};

545

#endif

546

547

#define FIRSTSOCKET 0

548

#define SECONDARYSOCKET 1

549

550

/* These function pointer types are here only to allow easier typecasting

551

within the source when we need to cast between data pointers (such as NULL)

552

and function pointers. */

553

typedef CURLcode (*Curl_do_more_func)(struct connectdata *, bool *);

554

typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode, bool);

555

556

557

enum expect100 {

558

EXP100_SEND_DATA, /* enough waiting, just send the body now */

559

EXP100_AWAITING_CONTINUE, /* waiting for the 100 Continue header */

560

EXP100_SENDING_REQUEST, /* still sending the request but will wait for

561

the 100 header once done with the request */

562

EXP100_FAILED /* used on 417 Expectation Failed */

563

};

564

565

/*

566

* Request specific data in the easy handle (SessionHandle). Previously,

567

* these members were on the connectdata struct but since a conn struct may

568

* now be shared between different SessionHandles, we store connection-specific

569

* data here. This struct only keeps stuff that's interesting for *this*

570

* request, as it will be cleared between multiple ones

571

*/

572

struct SingleRequest {

573

curl_off_t size; /* -1 if unknown at this point */

574

curl_off_t *bytecountp; /* return number of bytes read or NULL */

575

576

curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch,

577

-1 means unlimited */

578

curl_off_t *writebytecountp; /* return number of bytes written or NULL */

579

580

curl_off_t bytecount; /* total number of bytes read */

581

curl_off_t writebytecount; /* number of bytes written */

582

583

long headerbytecount; /* only count received headers */

584

long deductheadercount; /* this amount of bytes doesn't count when we check

585

if anything has been transferred at the end of a

586

connection. We use this counter to make only a

587

100 reply (without a following second response

588

code) result in a CURLE_GOT_NOTHING error code */

589

590

struct timeval start; /* transfer started at this time */

591

struct timeval now; /* current time */

592

bool header; /* incoming data has HTTP header */

593

enum {

594

HEADER_NORMAL, /* no bad header at all */

595

HEADER_PARTHEADER, /* part of the chunk is a bad header, the rest

596

is normal data */

597

HEADER_ALLBAD /* all was believed to be header */

598

} badheader; /* the header was deemed bad and will be

599

written as body */

600

int headerline; /* counts header lines to better track the

601

first one */

602

char *hbufp; /* points at *end* of header line */

603

size_t hbuflen;

604

char *str; /* within buf */

605

char *str_start; /* within buf */

606

char *end_ptr; /* within buf */

607

char *p; /* within headerbuff */

608

bool content_range; /* set TRUE if Content-Range: was found */

609

curl_off_t offset; /* possible resume offset read from the

610

Content-Range: header */

611

int httpcode; /* error code from the 'HTTP/1.? XXX' or

612

'RTSP/1.? XXX' line */

613

struct timeval start100; /* time stamp to wait for the 100 code from */

614

enum expect100 exp100; /* expect 100 continue state */

615

616

int auto_decoding; /* What content encoding. sec 3.5, RFC2616. */

617

618

#define IDENTITY 0 /* No encoding */

619

#define DEFLATE 1 /* zlib deflate [RFC 1950 & 1951] */

620

#define GZIP 2 /* gzip algorithm [RFC 1952] */

621

#define COMPRESS 3 /* Not handled, added for completeness */

622

623

#ifdef HAVE_LIBZ

624

zlibInitState zlib_init; /* possible zlib init state;

625

undefined if Content-Encoding header. */

626

z_stream z; /* State structure for zlib. */

627

#endif

628

629

time_t timeofdoc;

630

long bodywrites;

631

632

char *buf;

633

char *uploadbuf;

634

curl_socket_t maxfd;

635

636

int keepon;

637

638

bool upload_done; /* set to TRUE when doing chunked transfer-encoding upload

639

and we're uploading the last chunk */

640

641

bool ignorebody; /* we read a response-body but we ignore it! */

642

bool ignorecl; /* This HTTP response has no body so we ignore the Content-

643

Length: header */

644

645

char *location; /* This points to an allocated version of the Location:

646

header data */

647

char *newurl; /* Set to the new URL to use when a redirect or a retry is

648

wanted */

649

650

/* 'upload_present' is used to keep a byte counter of how much data there is

651

still left in the buffer, aimed for upload. */

652

ssize_t upload_present;

653

654

/* 'upload_fromhere' is used as a read-pointer when we uploaded parts of a

655

buffer, so the next read should read from where this pointer points to,

656

and the 'upload_present' contains the number of bytes available at this

657

position */

658

char *upload_fromhere;

659

660

bool chunk; /* if set, this is a chunked transfer-encoding */

661

bool upload_chunky; /* set TRUE if we are doing chunked transfer-encoding

662

on upload */

663

bool getheader; /* TRUE if header parsing is wanted */

664

665

bool forbidchunk; /* used only to explicitly forbid chunk-upload for

666

specific upload buffers. See readmoredata() in

667

http.c for details. */

668

};

669

670

/*

671

* Specific protocol handler.

672

*/

673

674

struct Curl_handler {

675

const char * scheme; /* URL scheme name. */

676

677

/* Complement to setup_connection_internals(). */

678

CURLcode (*setup_connection)(struct connectdata *);

679

680

/* These two functions MUST be set to be protocol dependent */

681

CURLcode (*do_it)(struct connectdata *, bool *done);

682

Curl_done_func done;

683

684

/* If the curl_do() function is better made in two halves, this

685

* curl_do_more() function will be called afterwards, if set. For example

686

* for doing the FTP stuff after the PASV/PORT command.

687

*/

688

Curl_do_more_func do_more;

689

690

/* This function *MAY* be set to a protocol-dependent function that is run

691

* after the connect() and everything is done, as a step in the connection.

692

* The 'done' pointer points to a bool that should be set to TRUE if the

693

* function completes before return. If it doesn't complete, the caller

694

* should call the curl_connecting() function until it is.

695

*/

696

CURLcode (*connect_it)(struct connectdata *, bool *done);

697

698

/* See above. Currently only used for FTP. */

699

CURLcode (*connecting)(struct connectdata *, bool *done);

700

CURLcode (*doing)(struct connectdata *, bool *done);

701

702

/* Called from the multi interface during the PROTOCONNECT phase, and it

703

should then return a proper fd set */

704

int (*proto_getsock)(struct connectdata *conn,

705

curl_socket_t *socks,

706

int numsocks);

707

708

/* Called from the multi interface during the DOING phase, and it should

709

then return a proper fd set */

710

int (*doing_getsock)(struct connectdata *conn,

711

curl_socket_t *socks,

712

int numsocks);

713

714

/* Called from the multi interface during the DO_MORE phase, and it should

715

then return a proper fd set */

716

int (*domore_getsock)(struct connectdata *conn,

717

curl_socket_t *socks,

718

int numsocks);

719

720

/* Called from the multi interface during the DO_DONE, PERFORM and

721

WAITPERFORM phases, and it should then return a proper fd set. Not setting

722

this will make libcurl use the generic default one. */

723

int (*perform_getsock)(const struct connectdata *conn,

724

curl_socket_t *socks,

725

int numsocks);

726

727

/* This function *MAY* be set to a protocol-dependent function that is run

728

* by the curl_disconnect(), as a step in the disconnection. If the handler

729

* is called because the connection has been considered dead, dead_connection

730

* is set to TRUE.

731

*/

732

CURLcode (*disconnect)(struct connectdata *, bool dead_connection);

733

734

/* If used, this function gets called from transfer.c:readwrite_data() to

735

allow the protocol to do extra reads/writes */

736

CURLcode (*readwrite)(struct SessionHandle *data, struct connectdata *conn,

737

ssize_t *nread, bool *readmore);

738

739

long defport; /* Default port. */

740

unsigned int protocol; /* See CURLPROTO_* */

741

unsigned int flags; /* Extra particular characteristics, see PROTOPT_* */

742

};

743

744

#define PROTOPT_NONE 0 /* nothing extra */

745

#define PROTOPT_SSL (1<<0) /* uses SSL */

746

#define PROTOPT_DUAL (1<<1) /* this protocol uses two connections */

747

#define PROTOPT_CLOSEACTION (1<<2) /* need action before socket close */

748

/* some protocols will have to call the underlying functions without regard to

749

what exact state the socket signals. IE even if the socket says "readable",

750

the send function might need to be called while uploading, or vice versa.

751

*/

752

#define PROTOPT_DIRLOCK (1<<3)

753

#define PROTOPT_NONETWORK (1<<4) /* protocol doesn't use the network! */

754

#define PROTOPT_NEEDSPWD (1<<5) /* needs a password, and if none is set it

755

gets a default */

756

#define PROTOPT_NOURLQUERY (1<<6) /* protocol can't handle

757

url query strings (?foo=bar) ! */

758

759

760

/* return the count of bytes sent, or -1 on error */

761

typedef ssize_t (Curl_send)(struct connectdata *conn, /* connection data */

762

int sockindex, /* socketindex */

763

const void *buf, /* data to write */

764

size_t len, /* max amount to write */

765

CURLcode *err); /* error to return */

766

767

/* return the count of bytes read, or -1 on error */

768

typedef ssize_t (Curl_recv)(struct connectdata *conn, /* connection data */

769

int sockindex, /* socketindex */

770

char *buf, /* store data here */

771

size_t len, /* max amount to read */

772

CURLcode *err); /* error to return */

773

774

/*

775

* The connectdata struct contains all fields and variables that should be

776

* unique for an entire connection.

777

*/

778

struct connectdata {

779

/* 'data' is the CURRENT SessionHandle using this connection -- take great

780

caution that this might very well vary between different times this

781

connection is used! */

782

struct SessionHandle *data;

783

784

/* chunk is for HTTP chunked encoding, but is in the general connectdata

785

struct only because we can do just about any protocol through a HTTP proxy

786

and a HTTP proxy may in fact respond using chunked encoding */

787

struct Curl_chunker chunk;

788

789

curl_closesocket_callback fclosesocket; /* function closing the socket(s) */

790

void *closesocket_client;

791

792

bool inuse; /* This is a marker for the connection cache logic. If this is

793

TRUE this handle is being used by an easy handle and cannot

794

be used by any other easy handle without careful

795

consideration (== only for pipelining). */

796

797

/**** Fields set when inited and not modified again */

798

long connectindex; /* what index in the connection cache connects index this

799

particular struct has */

800

801

/* 'dns_entry' is the particular host we use. This points to an entry in the

802

DNS cache and it will not get pruned while locked. It gets unlocked in

803

Curl_done(). This entry will be NULL if the connection is re-used as then

804

there is no name resolve done. */

805

struct Curl_dns_entry *dns_entry;

806

807

/* 'ip_addr' is the particular IP we connected to. It points to a struct

808

within the DNS cache, so this pointer is only valid as long as the DNS

809

cache entry remains locked. It gets unlocked in Curl_done() */

810

Curl_addrinfo *ip_addr;

811

812

/* 'ip_addr_str' is the ip_addr data as a human readable string.

813

It remains available as long as the connection does, which is longer than

814

the ip_addr itself. */

815

char ip_addr_str[MAX_IPADR_LEN];

816

817

unsigned int scope; /* address scope for IPv6 */

818

819

int socktype; /* SOCK_STREAM or SOCK_DGRAM */

820

821

struct hostname host;

822

struct hostname proxy;

823

824

long port; /* which port to use locally */

825

unsigned short remote_port; /* what remote port to connect to,

826

not the proxy port! */

827

828

/* 'primary_ip' and 'primary_port' get filled with peer's numerical

829

ip address and port number whenever an outgoing connection is

830

*attempted* from the primary socket to a remote address. When more

831

than one address is tried for a connection these will hold data

832

for the last attempt. When the connection is actually established

833

these are updated with data which comes directly from the socket. */

834

835

char primary_ip[MAX_IPADR_LEN];

836

long primary_port;

837

838

/* 'local_ip' and 'local_port' get filled with local's numerical

839

ip address and port number whenever an outgoing connection is

840

**established** from the primary socket to a remote address. */

841

842

char local_ip[MAX_IPADR_LEN];

843

long local_port;

844

845

char *user; /* user name string, allocated */

846

char *passwd; /* password string, allocated */

847

848

char *proxyuser; /* proxy user name string, allocated */

849

char *proxypasswd; /* proxy password string, allocated */

850

curl_proxytype proxytype; /* what kind of proxy that is in use */

851

852

int httpversion; /* the HTTP version*10 reported by the server */

853

int rtspversion; /* the RTSP version*10 reported by the server */

854

855

struct timeval now; /* "current" time */

856

struct timeval created; /* creation time */

857

curl_socket_t sock[2]; /* two sockets, the second is used for the data

858

transfer when doing FTP */

859

bool sock_accepted[2]; /* TRUE if the socket on this index was created with

860

accept() */

861

Curl_recv *recv[2];

862

Curl_send *send[2];

863

864

struct ssl_connect_data ssl[2]; /* this is for ssl-stuff */

865

struct ssl_config_data ssl_config;

866

867

struct ConnectBits bits; /* various state-flags for this connection */

868

869

/* connecttime: when connect() is called on the current IP address. Used to

870

be able to track when to move on to try next IP - but only when the multi

871

interface is used. */

872

struct timeval connecttime;

873

/* The two fields below get set in Curl_connecthost */

874

int num_addr; /* number of addresses to try to connect to */

875

long timeoutms_per_addr; /* how long time in milliseconds to spend on

876

trying to connect to each IP address */

877

878

const struct Curl_handler *handler; /* Connection's protocol handler */

879

const struct Curl_handler *given; /* The protocol first given */

880

881

long ip_version; /* copied from the SessionHandle at creation time */

882

883

/**** curl_get() phase fields */

884

885

curl_socket_t sockfd; /* socket to read from or CURL_SOCKET_BAD */

886

curl_socket_t writesockfd; /* socket to write to, it may very

887

well be the same we read from.

888

CURL_SOCKET_BAD disables */

889

890

/** Dynamicly allocated strings, MUST be freed before this **/

891

/** struct is killed. **/

892

struct dynamically_allocated_data {

893

char *proxyuserpwd;

894

char *uagent;

895

char *accept_encoding;

896

char *userpwd;

897

char *rangeline;

898

char *ref;

899

char *host;

900

char *cookiehost;

901

char *rtsp_transport;

902

char *te; /* TE: request header */

903

} allocptr;

904

905

int sec_complete; /* if kerberos is enabled for this connection */

906

#if defined(HAVE_KRB4) || defined(HAVE_GSSAPI)

907

enum protection_level command_prot;

908

enum protection_level data_prot;

909

enum protection_level request_data_prot;

910

size_t buffer_size;

911

struct krb4buffer in_buffer;

912

void *app_data;

913

const struct Curl_sec_client_mech *mech;

914

struct sockaddr_in local_addr;

915

#endif

916

917

/* the two following *_inuse fields are only flags, not counters in any way.

918

If TRUE it means the channel is in use, and if FALSE it means the channel

919

is up for grabs by one. */

920

921

bool readchannel_inuse; /* whether the read channel is in use by an easy

922

handle */

923

bool writechannel_inuse; /* whether the write channel is in use by an easy

924

handle */

925

bool server_supports_pipelining; /* TRUE if server supports pipelining,

926

set after first response */

927

928

struct curl_llist *send_pipe; /* List of handles waiting to

929

send on this pipeline */

930

struct curl_llist *recv_pipe; /* List of handles waiting to read

931

their responses on this pipeline */

932

struct curl_llist *pend_pipe; /* List of pending handles on

933

this pipeline */

934

struct curl_llist *done_pipe; /* Handles that are finished, but

935

still reference this connectdata */

936

#define MAX_PIPELINE_LENGTH 5

937

938

char* master_buffer; /* The master buffer allocated on-demand;

939

used for pipelining. */

940

size_t read_pos; /* Current read position in the master buffer */

941

size_t buf_len; /* Length of the buffer?? */

942

943

944

curl_seek_callback seek_func; /* function that seeks the input */

945

void *seek_client; /* pointer to pass to the seek() above */

946

947

/*************** Request - specific items ************/

948

949

/* previously this was in the urldata struct */

950

curl_read_callback fread_func; /* function that reads the input */

951

void *fread_in; /* pointer to pass to the fread() above */

952

953

struct ntlmdata ntlm; /* NTLM differs from other authentication schemes

954

because it authenticates connections, not

955

single requests! */

956

struct ntlmdata proxyntlm; /* NTLM data for proxy */

957

958

#if defined(USE_NTLM) && defined(NTLM_WB_ENABLED)

959

/* used for communication with Samba's winbind daemon helper ntlm_auth */

960

curl_socket_t ntlm_auth_hlpr_socket;

961

pid_t ntlm_auth_hlpr_pid;

962

char* challenge_header;

963

char* response_header;

964

#endif

965

966

char syserr_buf [256]; /* buffer for Curl_strerror() */

967

968

#ifdef CURLRES_ASYNCH

969

/* data used for the asynch name resolve callback */

970

struct Curl_async async;

971

#endif

972

973

/* These three are used for chunked-encoding trailer support */

974

char *trailer; /* allocated buffer to store trailer in */

975

int trlMax; /* allocated buffer size */

976

int trlPos; /* index of where to store data */

977

978

union {

979

struct ftp_conn ftpc;

980

struct ssh_conn sshc;

981

struct tftp_state_data *tftpc;

982

struct imap_conn imapc;

983

struct pop3_conn pop3c;

984

struct smtp_conn smtpc;

985

struct rtsp_conn rtspc;

986

void *generic;

987

} proto;

988

989

int cselect_bits; /* bitmask of socket events */

990

int waitfor; /* current READ/WRITE bits to wait for */

991

992

#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)

993

int socks5_gssapi_enctype;

994

#endif

995

996

long verifypeer;

997

long verifyhost;

998

999

/* When this connection is created, store the conditions for the local end

1000

bind. This is stored before the actual bind and before any connection is

1001

made and will serve the purpose of being used for comparison reasons so

1002

that subsequent bound-requested connections aren't accidentally re-using

1003

wrong connections. */

1004

char *localdev;

1005

unsigned short localport;

1006

int localportrange;

1007

1008

/* tunnel as in tunnel through a HTTP proxy with CONNECT */

1009

enum {

1010

TUNNEL_INIT, /* init/default/no tunnel state */

1011

TUNNEL_CONNECT, /* CONNECT has been sent off */

1012

TUNNEL_COMPLETE /* CONNECT response received completely */

1013

} tunnel_state[2]; /* two separate ones to allow FTP */

1014

};

1015

1016

/* The end of connectdata. */

1017

1018

/*

1019

* Struct to keep statistical and informational data.

1020

*/

1021

struct PureInfo {

1022

int httpcode; /* Recent HTTP, FTP, or RTSP response code */

1023

int httpproxycode; /* response code from proxy when received separate */

1024

int httpversion; /* the http version number X.Y = X*10+Y */

1025

long filetime; /* If requested, this is might get set. Set to -1 if the time

1026

was unretrievable. We cannot have this of type time_t,

1027

since time_t is unsigned on several platforms such as

1028

OpenVMS. */

1029

bool timecond; /* set to TRUE if the time condition didn't match, which

1030

thus made the document NOT get fetched */

1031

long header_size; /* size of read header(s) in bytes */

1032

long request_size; /* the amount of bytes sent in the request(s) */

1033

unsigned long proxyauthavail; /* what proxy auth types were announced */

1034

unsigned long httpauthavail; /* what host auth types were announced */

1035

long numconnects; /* how many new connection did libcurl created */

1036

char *contenttype; /* the content type of the object */

1037

char *wouldredirect; /* URL this would've been redirected to if asked to */

1038

1039

/* PureInfo members 'conn_primary_ip', 'conn_primary_port', 'conn_local_ip'

1040

and, 'conn_local_port' are copied over from the connectdata struct in

1041

order to allow curl_easy_getinfo() to return this information even when

1042

the session handle is no longer associated with a connection, and also

1043

allow curl_easy_reset() to clear this information from the session handle

1044

without disturbing information which is still alive, and that might be

1045

reused, in the connection cache. */

1046

1047

char conn_primary_ip[MAX_IPADR_LEN];

1048

long conn_primary_port;

1049

1050

char conn_local_ip[MAX_IPADR_LEN];

1051

long conn_local_port;

1052

1053

struct curl_certinfo certs; /* info about the certs, only populated in

1054

OpenSSL builds. Asked for with

1055

CURLOPT_CERTINFO / CURLINFO_CERTINFO */

1056

};

1057

1058

1059

struct Progress {

1060

long lastshow; /* time() of the last displayed progress meter or NULL to

1061

force redraw at next call */

1062

curl_off_t size_dl; /* total expected size */

1063

curl_off_t size_ul; /* total expected size */

1064

curl_off_t downloaded; /* transferred so far */

1065

curl_off_t uploaded; /* transferred so far */

1066

1067

curl_off_t current_speed; /* uses the currently fastest transfer */

1068

1069

bool callback; /* set when progress callback is used */

1070

int width; /* screen width at download start */

1071

int flags; /* see progress.h */

1072

1073

double timespent;

1074

1075

curl_off_t dlspeed;

1076

curl_off_t ulspeed;

1077

1078

double t_nslookup;

1079

double t_connect;

1080

double t_appconnect;

1081

double t_pretransfer;

1082

double t_starttransfer;

1083

double t_redirect;

1084

1085

struct timeval start;

1086

struct timeval t_startsingle;

1087

struct timeval t_acceptdata;

1088

#define CURR_TIME (5+1) /* 6 entries for 5 seconds */

1089

1090

curl_off_t speeder[ CURR_TIME ];

1091

struct timeval speeder_time[ CURR_TIME ];

1092

int speeder_c;

1093

};

1094

1095

typedef enum {

1096

HTTPREQ_NONE, /* first in list */

1097

HTTPREQ_GET,

1098

HTTPREQ_POST,

1099

HTTPREQ_POST_FORM, /* we make a difference internally */

1100

HTTPREQ_PUT,

1101

HTTPREQ_HEAD,

1102

HTTPREQ_CUSTOM,

1103

HTTPREQ_LAST /* last in list */

1104

} Curl_HttpReq;

1105

1106

typedef enum {

1107

RTSPREQ_NONE, /* first in list */

1108

RTSPREQ_OPTIONS,

1109

RTSPREQ_DESCRIBE,

1110

RTSPREQ_ANNOUNCE,

1111

RTSPREQ_SETUP,

1112

RTSPREQ_PLAY,

1113

RTSPREQ_PAUSE,

1114

RTSPREQ_TEARDOWN,

1115

RTSPREQ_GET_PARAMETER,

1116

RTSPREQ_SET_PARAMETER,

1117

RTSPREQ_RECORD,

1118

RTSPREQ_RECEIVE,

1119

RTSPREQ_LAST /* last in list */

1120

} Curl_RtspReq;

1121

1122

/*

1123

* Values that are generated, temporary or calculated internally for a

1124

* "session handle" must be defined within the 'struct UrlState'. This struct

1125

* will be used within the SessionHandle struct. When the 'SessionHandle'

1126

* struct is cloned, this data MUST NOT be copied.

1127

*

1128

* Remember that any "state" information goes globally for the curl handle.

1129

* Session-data MUST be put in the connectdata struct and here. */

1130

#define MAX_CURL_USER_LENGTH 256

1131

#define MAX_CURL_PASSWORD_LENGTH 256

1132

#define MAX_CURL_USER_LENGTH_TXT "255"

1133

#define MAX_CURL_PASSWORD_LENGTH_TXT "255"

1134

1135

struct auth {

1136

unsigned long want; /* Bitmask set to the authentication methods wanted by

1137

app (with CURLOPT_HTTPAUTH or CURLOPT_PROXYAUTH). */

1138

unsigned long picked;

1139

unsigned long avail; /* Bitmask for what the server reports to support for

1140

this resource */

1141

bool done; /* TRUE when the auth phase is done and ready to do the *actual*

1142

request */

1143

bool multi; /* TRUE if this is not yet authenticated but within the auth

1144

multipass negotiation */

1145

bool iestyle; /* TRUE if digest should be done IE-style or FALSE if it should

1146

be RFC compliant */

1147

};

1148

1149

struct conncache {

1150

/* 'connects' will be an allocated array with pointers. If the pointer is

1151

set, it holds an allocated connection. */

1152

struct connectdata **connects;

1153

long num; /* number of entries of the 'connects' array */

1154

enum {

1155

CONNCACHE_PRIVATE, /* used for an easy handle alone */

1156

CONNCACHE_MULTI /* shared within a multi handle */

1157

} type;

1158

};

1159

1160

1161

struct UrlState {

1162

enum {

1163

Curl_if_none,

1164

Curl_if_easy,

1165

Curl_if_multi

1166

} used_interface;

1167

1168

struct conncache *connc; /* points to the connection cache this handle

1169

uses */

1170

1171

/* buffers to store authentication data in, as parsed from input options */

1172

struct timeval keeps_speed; /* for the progress meter really */

1173

1174

long lastconnect; /* index of most recent connect or -1 if undefined */

1175

1176

char *headerbuff; /* allocated buffer to store headers in */

1177

size_t headersize; /* size of the allocation */

1178

1179

char buffer[BUFSIZE+1]; /* download buffer */

1180

char uploadbuffer[BUFSIZE+1]; /* upload buffer */

1181

curl_off_t current_speed; /* the ProgressShow() funcion sets this,

1182

bytes / second */

1183

bool this_is_a_follow; /* this is a followed Location: request */

1184

1185

char *first_host; /* if set, this should be the host name that we will

1186

sent authorization to, no else. Used to make Location:

1187

following not keep sending user+password... This is

1188

strdup() data.

1189

*/

1190

struct curl_ssl_session *session; /* array of 'max_ssl_sessions' size */

1191

long sessionage; /* number of the most recent session */

1192

char *tempwrite; /* allocated buffer to keep data in when a write

1193

callback returns to make the connection paused */

1194

size_t tempwritesize; /* size of the 'tempwrite' allocated buffer */

1195

int tempwritetype; /* type of the 'tempwrite' buffer as a bitmask that is

1196

used with Curl_client_write() */

1197

char *scratch; /* huge buffer[BUFSIZE*2] when doing upload CRLF replacing */

1198

bool errorbuf; /* Set to TRUE if the error buffer is already filled in.

1199

This must be set to FALSE every time _easy_perform() is

1200

called. */

1201

int os_errno; /* filled in with errno whenever an error occurs */

1202

#ifdef HAVE_SIGNAL

1203

/* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */

1204

void (*prev_signal)(int sig);

1205

#endif

1206

bool allow_port; /* Is set.use_port allowed to take effect or not. This

1207

is always set TRUE when curl_easy_perform() is called. */

1208

struct digestdata digest; /* state data for host Digest auth */

1209

struct digestdata proxydigest; /* state data for proxy Digest auth */

1210

1211

#ifdef USE_HTTP_NEGOTIATE

1212

struct negotiatedata negotiate; /* state data for host Negotiate auth */

1213

struct negotiatedata proxyneg; /* state data for proxy Negotiate auth */

1214

#endif

1215

1216

struct auth authhost; /* auth details for host */

1217

struct auth authproxy; /* auth details for proxy */

1218

1219

bool authproblem; /* TRUE if there's some problem authenticating */

1220

1221

void *resolver; /* resolver state, if it is used in the URL state -

1222

ares_channel f.e. */

1223

1224

#if defined(USE_SSLEAY) && defined(HAVE_OPENSSL_ENGINE_H)

1225

ENGINE *engine;

1226

#endif /* USE_SSLEAY */

1227

struct timeval expiretime; /* set this with Curl_expire() only */

1228

struct Curl_tree timenode; /* for the splay stuff */

1229

struct curl_llist *timeoutlist; /* list of pending timeouts */

1230

1231

/* a place to store the most recently set FTP entrypath */

1232

char *most_recent_ftp_entrypath;

1233

1234

/* set after initial USER failure, to prevent an authentication loop */

1235

bool ftp_trying_alternative;

1236

1237

int httpversion; /* the lowest HTTP version*10 reported by any server

1238

involved in this request */

1239

bool expect100header; /* TRUE if we added Expect: 100-continue */

1240

1241

bool pipe_broke; /* TRUE if the connection we were pipelined on broke

1242

and we need to restart from the beginning */

1243

1244

#if !defined(WIN32) && !defined(MSDOS) && !defined(__EMX__) && \

1245

!defined(__SYMBIAN32__)

1246

/* do FTP line-end conversions on most platforms */

1247

#define CURL_DO_LINEEND_CONV

1248

/* for FTP downloads: track CRLF sequences that span blocks */

1249

bool prev_block_had_trailing_cr;

1250

/* for FTP downloads: how many CRLFs did we converted to LFs? */

1251

curl_off_t crlf_conversions;

1252

#endif

1253

/* If set to non-NULL, there's a connection in a shared connection cache

1254

that uses this handle so we can't kill this SessionHandle just yet but

1255

must keep it around and add it to the list of handles to kill once all

1256

its connections are gone */

1257

void *shared_conn;

1258

bool closed; /* set to TRUE when curl_easy_cleanup() has been called on this

1259

handle, but it is kept around as mentioned for

1260

shared_conn */

1261

char *pathbuffer;/* allocated buffer to store the URL's path part in */

1262

char *path; /* path to use, points to somewhere within the pathbuffer

1263

area */

1264

bool slash_removed; /* set TRUE if the 'path' points to a path where the

1265

initial URL slash separator has been taken off */

1266

bool use_range;

1267

bool rangestringalloc; /* the range string is malloc()'ed */

1268

1269

char *range; /* range, if used. See README for detailed specification on

1270

this syntax. */

1271

curl_off_t resume_from; /* continue [ftp] transfer from here */

1272

1273

/* This RTSP state information survives requests and connections */

1274

long rtsp_next_client_CSeq; /* the session's next client CSeq */

1275

long rtsp_next_server_CSeq; /* the session's next server CSeq */

1276

long rtsp_CSeq_recv; /* most recent CSeq received */

1277

1278

/* Protocol specific data.

1279

*

1280

*************************************************************************

1281

* Note that this data will be REMOVED after each request, so anything that

1282

* should be kept/stored on a per-connection basis and thus live for the

1283

* next request on the same connection MUST be put in the connectdata struct!

1284

*************************************************************************/

1285

union {

1286

struct HTTP *http;

1287

struct HTTP *https; /* alias, just for the sake of being more readable */

1288

struct RTSP *rtsp;

1289

struct FTP *ftp;

1290

/* void *tftp; not used */

1291

struct FILEPROTO *file;

1292

void *telnet; /* private for telnet.c-eyes only */

1293

void *generic;

1294

struct SSHPROTO *ssh;

1295

struct FTP *imap;

1296

struct FTP *pop3;

1297

struct FTP *smtp;

1298

} proto;

1299

/* current user of this SessionHandle instance, or NULL */

1300

struct connectdata *current_conn;

1301

1302

/* if true, force SSL connection retry (workaround for certain servers) */

1303

bool ssl_connect_retry;

1304

};

1305

1306

1307

/*

1308

* This 'DynamicStatic' struct defines dynamic states that actually change

1309

* values in the 'UserDefined' area, which MUST be taken into consideration

1310

* if the UserDefined struct is cloned or similar. You can probably just

1311

* copy these, but each one indicate a special action on other data.

1312

*/

1313

1314

struct DynamicStatic {

1315

char *url; /* work URL, copied from UserDefined */

1316

bool url_alloc; /* URL string is malloc()'ed */

1317

char *referer; /* referer string */

1318

bool referer_alloc; /* referer sting is malloc()ed */

1319

struct curl_slist *cookielist; /* list of cookie files set by

1320

curl_easy_setopt(COOKIEFILE) calls */

1321

struct curl_slist *resolve; /* set to point to the set.resolve list when

1322

this should be dealt with in pretransfer */

1323

};

1324

1325

/*

1326

* This 'UserDefined' struct must only contain data that is set once to go

1327

* for many (perhaps) independent connections. Values that are generated or

1328

* calculated internally for the "session handle" MUST be defined within the

1329

* 'struct UrlState' instead. The only exceptions MUST note the changes in

1330

* the 'DynamicStatic' struct.

1331

* Character pointer fields point to dynamic storage, unless otherwise stated.

1332

*/

1333

struct Curl_one_easy; /* declared and used only in multi.c */

1334

struct Curl_multi; /* declared and used only in multi.c */

1335

1336

enum dupstring {

1337

STRING_CERT, /* client certificate file name */

1338

STRING_CERT_TYPE, /* format for certificate (default: PEM)*/

1339

STRING_COOKIE, /* HTTP cookie string to send */

1340

STRING_COOKIEJAR, /* dump all cookies to this file */

1341

STRING_CUSTOMREQUEST, /* HTTP/FTP/RTSP request/method to use */

1342

STRING_DEVICE, /* local network interface/address to use */

1343

STRING_ENCODING, /* Accept-Encoding string */

1344

STRING_FTP_ACCOUNT, /* ftp account data */

1345

STRING_FTP_ALTERNATIVE_TO_USER, /* command to send if USER/PASS fails */

1346

STRING_FTPPORT, /* port to send with the FTP PORT command */

1347

STRING_KEY, /* private key file name */

1348

STRING_KEY_PASSWD, /* plain text private key password */

1349

STRING_KEY_TYPE, /* format for private key (default: PEM) */

1350

STRING_KRB_LEVEL, /* krb security level */

1351

STRING_NETRC_FILE, /* if not NULL, use this instead of trying to find

1352

$HOME/.netrc */

1353

STRING_COPYPOSTFIELDS, /* if POST, set the fields' values here */

1354

STRING_PROXY, /* proxy to use */

1355

STRING_SET_RANGE, /* range, if used */

1356

STRING_SET_REFERER, /* custom string for the HTTP referer field */

1357

STRING_SET_URL, /* what original URL to work on */

1358

STRING_SSL_CAPATH, /* CA directory name (doesn't work on windows) */

1359

STRING_SSL_CAFILE, /* certificate file to verify peer against */

1360

STRING_SSL_CIPHER_LIST, /* list of ciphers to use */

1361

STRING_SSL_EGDSOCKET, /* path to file containing the EGD daemon socket */

1362

STRING_SSL_RANDOM_FILE, /* path to file containing "random" data */

1363

STRING_USERAGENT, /* User-Agent string */

1364

STRING_SSL_CRLFILE, /* crl file to check certificate */

1365

STRING_SSL_ISSUERCERT, /* issuer cert file to check certificate */

1366

STRING_USERNAME, /* <username>, if used */

1367

STRING_PASSWORD, /* <password>, if used */

1368

STRING_PROXYUSERNAME, /* Proxy <username>, if used */

1369

STRING_PROXYPASSWORD, /* Proxy <password>, if used */

1370

STRING_NOPROXY, /* List of hosts which should not use the proxy, if

1371

used */

1372

STRING_RTSP_SESSION_ID, /* Session ID to use */

1373

STRING_RTSP_STREAM_URI, /* Stream URI for this request */

1374

STRING_RTSP_TRANSPORT, /* Transport for this session */

1375

#ifdef USE_LIBSSH2

1376

STRING_SSH_PRIVATE_KEY, /* path to the private key file for auth */

1377

STRING_SSH_PUBLIC_KEY, /* path to the public key file for auth */

1378

STRING_SSH_HOST_PUBLIC_KEY_MD5, /* md5 of host public key in ascii hex */

1379

STRING_SSH_KNOWNHOSTS, /* file name of knownhosts file */

1380

#endif

1381

#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)

1382

STRING_SOCKS5_GSSAPI_SERVICE, /* GSSAPI service name */

1383

#endif

1384

STRING_MAIL_FROM,

1385

STRING_MAIL_AUTH,

1386

1387

#ifdef USE_TLS_SRP

1388

STRING_TLSAUTH_USERNAME, /* TLS auth <username> */

1389

STRING_TLSAUTH_PASSWORD, /* TLS auth <password> */

1390

#endif

1391

1392

/* -- end of strings -- */

1393

STRING_LAST /* not used, just an end-of-list marker */

1394

};

1395

1396

struct UserDefined {

1397

FILE *err; /* the stderr user data goes here */

1398

void *debugdata; /* the data that will be passed to fdebug */

1399

char *errorbuffer; /* (Static) store failure messages in here */

1400

long proxyport; /* If non-zero, use this port number by default. If the

1401

proxy string features a ":[port]" that one will override

1402

this. */

1403

void *out; /* the fetched file goes here */

1404

void *in; /* the uploaded file is read from here */

1405

void *writeheader; /* write the header to this if non-NULL */

1406

void *rtp_out; /* write RTP to this if non-NULL */

1407

long use_port; /* which port to use (when not using default) */

1408

unsigned long httpauth; /* kind of HTTP authentication to use (bitmask) */

1409

unsigned long proxyauth; /* kind of proxy authentication to use (bitmask) */

1410

long followlocation; /* as in HTTP Location: */

1411

long maxredirs; /* maximum no. of http(s) redirects to follow, set to -1

1412

for infinity */

1413

1414

int keep_post; /* keep POSTs as POSTs after a 30x request; each

1415

bit represents a request, from 301 to 303 */

1416

bool free_referer; /* set TRUE if 'referer' points to a string we

1417

allocated */

1418

void *postfields; /* if POST, set the fields' values here */

1419

curl_seek_callback seek_func; /* function that seeks the input */

1420

curl_off_t postfieldsize; /* if POST, this might have a size to use instead

1421

of strlen(), and then the data *may* be binary

1422

(contain zero bytes) */

1423

unsigned short localport; /* local port number to bind to */

1424

int localportrange; /* number of additional port numbers to test in case the

1425

'localport' one can't be bind()ed */

1426

curl_write_callback fwrite_func; /* function that stores the output */

1427

curl_write_callback fwrite_header; /* function that stores headers */

1428

curl_write_callback fwrite_rtp; /* function that stores interleaved RTP */

1429

curl_read_callback fread_func; /* function that reads the input */

1430

int is_fread_set; /* boolean, has read callback been set to non-NULL? */

1431

int is_fwrite_set; /* boolean, has write callback been set to non-NULL? */

1432

curl_progress_callback fprogress; /* function for progress information */

1433

curl_debug_callback fdebug; /* function that write informational data */

1434

curl_ioctl_callback ioctl_func; /* function for I/O control */

1435

curl_sockopt_callback fsockopt; /* function for setting socket options */

1436

void *sockopt_client; /* pointer to pass to the socket options callback */

1437

curl_opensocket_callback fopensocket; /* function for checking/translating

1438

the address and opening the

1439

socket */

1440

void* opensocket_client;

1441

curl_closesocket_callback fclosesocket; /* function for closing the

1442

socket */

1443

void* closesocket_client;

1444

1445

void *seek_client; /* pointer to pass to the seek callback */

1446

/* the 3 curl_conv_callback functions below are used on non-ASCII hosts */

1447

/* function to convert from the network encoding: */

1448

curl_conv_callback convfromnetwork;

1449

/* function to convert to the network encoding: */

1450

curl_conv_callback convtonetwork;

1451

/* function to convert from UTF-8 encoding: */

1452

curl_conv_callback convfromutf8;

1453

1454

void *progress_client; /* pointer to pass to the progress callback */

1455

void *ioctl_client; /* pointer to pass to the ioctl callback */

1456

long timeout; /* in milliseconds, 0 means no timeout */

1457

long connecttimeout; /* in milliseconds, 0 means no timeout */

1458

long accepttimeout; /* in milliseconds, 0 means no timeout */

1459

long server_response_timeout; /* in milliseconds, 0 means no timeout */

1460

long tftp_blksize ; /* in bytes, 0 means use default */

1461

curl_off_t infilesize; /* size of file to upload, -1 means unknown */

1462

long low_speed_limit; /* bytes/second */

1463

long low_speed_time; /* number of seconds */

1464

curl_off_t max_send_speed; /* high speed limit in bytes/second for upload */

1465

curl_off_t max_recv_speed; /* high speed limit in bytes/second for

1466

download */

1467

curl_off_t set_resume_from; /* continue [ftp] transfer from here */

1468

struct curl_slist *headers; /* linked list of extra headers */

1469

struct curl_httppost *httppost; /* linked list of POST data */

1470

bool cookiesession; /* new cookie session? */

1471

bool crlf; /* convert crlf on ftp upload(?) */

1472

struct curl_slist *quote; /* after connection is established */

1473

struct curl_slist *postquote; /* after the transfer */

1474

struct curl_slist *prequote; /* before the transfer, after type */

1475

struct curl_slist *source_quote; /* 3rd party quote */

1476

struct curl_slist *source_prequote; /* in 3rd party transfer mode - before

1477

the transfer on source host */

1478

struct curl_slist *source_postquote; /* in 3rd party transfer mode - after

1479

the transfer on source host */

1480

struct curl_slist *telnet_options; /* linked list of telnet options */

1481

struct curl_slist *resolve; /* list of names to add/remove from

1482

DNS cache */

1483

curl_TimeCond timecondition; /* kind of time/date comparison */

1484

time_t timevalue; /* what time to compare with */

1485

Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */

1486

long httpversion; /* when non-zero, a specific HTTP version requested to

1487

be used in the library's request(s) */

1488

struct ssl_config_data ssl; /* user defined SSL stuff */

1489

curl_proxytype proxytype; /* what kind of proxy that is in use */

1490

long dns_cache_timeout; /* DNS cache timeout */

1491

long buffer_size; /* size of receive buffer to use */

1492

void *private_data; /* application-private data */

1493

1494

struct Curl_one_easy *one_easy; /* When adding an easy handle to a multi

1495

handle, an internal 'Curl_one_easy'

1496

struct is created and this is a pointer

1497

to the particular struct associated with

1498

this SessionHandle */

1499

1500

struct curl_slist *http200aliases; /* linked list of aliases for http200 */

1501

1502

long ipver; /* the CURL_IPRESOLVE_* defines in the public header file

1503

0 - whatever, 1 - v2, 2 - v6 */

1504

1505

curl_off_t max_filesize; /* Maximum file size to download */

1506

1507

curl_ftpfile ftp_filemethod; /* how to get to a file when FTP is used */

1508

1509

int ftp_create_missing_dirs; /* 1 - create directories that don't exist

1510

2 - the same but also allow MKD to fail once

1511

*/

1512

1513

curl_sshkeycallback ssh_keyfunc; /* key matching callback */

1514

void *ssh_keyfunc_userp; /* custom pointer to callback */

1515

1516

/* Here follows boolean settings that define how to behave during

1517

this session. They are STATIC, set by libcurl users or at least initially

1518

and they don't change during operations. */

1519

1520

bool printhost; /* printing host name in debug info */

1521

bool get_filetime; /* get the time and get of the remote file */

1522

bool tunnel_thru_httpproxy; /* use CONNECT through a HTTP proxy */

1523

bool prefer_ascii; /* ASCII rather than binary */

1524

bool ftp_append; /* append, not overwrite, on upload */

1525

bool ftp_list_only; /* switch FTP command for listing directories */

1526

bool ftp_use_port; /* use the FTP PORT command */

1527

bool hide_progress; /* don't use the progress meter */

1528

bool http_fail_on_error; /* fail on HTTP error codes >= 300 */

1529

bool http_follow_location; /* follow HTTP redirects */

1530

bool http_transfer_encoding; /* request compressed HTTP transfer-encoding */

1531

bool http_disable_hostname_check_before_authentication;

1532

bool include_header; /* include received protocol headers in data output */

1533

bool http_set_referer; /* is a custom referer used */

1534

bool http_auto_referer; /* set "correct" referer when following location: */

1535

bool opt_no_body; /* as set with CURLOPT_NO_BODY */

1536

bool set_port; /* custom port number used */

1537

bool upload; /* upload request */

1538

enum CURL_NETRC_OPTION

1539

use_netrc; /* defined in include/curl.h */

1540

bool verbose; /* output verbosity */

1541

bool krb; /* kerberos connection requested */

1542

bool reuse_forbid; /* forbidden to be reused, close after use */

1543

bool reuse_fresh; /* do not re-use an existing connection */

1544

bool ftp_use_epsv; /* if EPSV is to be attempted or not */

1545

bool ftp_use_eprt; /* if EPRT is to be attempted or not */

1546

bool ftp_use_pret; /* if PRET is to be used before PASV or not */

1547

1548

curl_usessl use_ssl; /* if AUTH TLS is to be attempted etc, for FTP or

1549

IMAP or POP3 or others! */

1550

curl_ftpauth ftpsslauth; /* what AUTH XXX to be attempted */

1551

curl_ftpccc ftp_ccc; /* FTP CCC options */

1552

bool no_signal; /* do not use any signal/alarm handler */

1553

bool global_dns_cache; /* subject for future removal */

1554

bool tcp_nodelay; /* whether to enable TCP_NODELAY or not */

1555

bool ignorecl; /* ignore content length */

1556

bool ftp_skip_ip; /* skip the IP address the FTP server passes on to

1557

us */

1558

bool connect_only; /* make connection, let application use the socket */

1559

bool ssl_enable_beast; /* especially allow this flaw for interoperability's

1560

sake*/

1561

long ssh_auth_types; /* allowed SSH auth types */

1562

bool http_te_skip; /* pass the raw body data to the user, even when

1563

transfer-encoded (chunked, compressed) */

1564

bool http_ce_skip; /* pass the raw body data to the user, even when

1565

content-encoded (chunked, compressed) */

1566

long new_file_perms; /* Permissions to use when creating remote files */

1567

long new_directory_perms; /* Permissions to use when creating remote dirs */

1568

bool proxy_transfer_mode; /* set transfer mode (;type=<a|i>) when doing FTP

1569

via an HTTP proxy */

1570

char *str[STRING_LAST]; /* array of strings, pointing to allocated memory */

1571

unsigned int scope; /* address scope for IPv6 */

1572

long allowed_protocols;

1573

long redir_protocols;

1574

#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)

1575

long socks5_gssapi_nec; /* flag to support nec socks5 server */

1576

#endif

1577

struct curl_slist *mail_rcpt; /* linked list of mail recipients */

1578

/* Common RTSP header options */

1579

Curl_RtspReq rtspreq; /* RTSP request type */

1580

long rtspversion; /* like httpversion, for RTSP */

1581

bool wildcardmatch; /* enable wildcard matching */

1582

curl_chunk_bgn_callback chunk_bgn; /* called before part of transfer

1583

starts */

1584

curl_chunk_end_callback chunk_end; /* called after part transferring

1585

stopped */

1586

curl_fnmatch_callback fnmatch; /* callback to decide which file corresponds

1587

to pattern (e.g. if WILDCARDMATCH is on) */

1588

void *fnmatch_data;

1589

1590

long gssapi_delegation; /* GSSAPI credential delegation, see the

1591

documentation of CURLOPT_GSSAPI_DELEGATION */

1592

1593

bool tcp_keepalive; /* use TCP keepalives */

1594

long tcp_keepidle; /* seconds in idle before sending keepalive probe */

1595

long tcp_keepintvl; /* seconds between TCP keepalive probes */

1596

};

1597

1598

struct Names {

1599

struct curl_hash *hostcache;

1600

enum {

1601

HCACHE_NONE, /* not pointing to anything */

1602

HCACHE_PRIVATE, /* points to our own */

1603

HCACHE_GLOBAL, /* points to the (shrug) global one */

1604

HCACHE_MULTI, /* points to a shared one in the multi handle */

1605

HCACHE_SHARED /* points to a shared one in a shared object */

1606

} hostcachetype;

1607

};

1608

1609

/*

1610

* The 'connectdata' struct MUST have all the connection oriented stuff as we

1611

* may have several simultaneous connections and connection structs in memory.

1612

*

1613

* The 'struct UserDefined' must only contain data that is set once to go for

1614

* many (perhaps) independent connections. Values that are generated or

1615

* calculated internally for the "session handle" must be defined within the

1616

* 'struct UrlState' instead.

1617

*/

1618

1619

struct SessionHandle {

1620

struct Names dns;

1621

struct Curl_multi *multi; /* if non-NULL, points to the multi handle

1622

struct to which this "belongs" */

1623

struct Curl_one_easy *multi_pos; /* if non-NULL, points to its position

1624

in multi controlling structure to assist

1625

in removal. */

1626

struct Curl_share *share; /* Share, handles global variable mutexing */

1627

struct SingleRequest req; /* Request-specific data */

1628

struct UserDefined set; /* values set by the libcurl user */

1629

struct DynamicStatic change; /* possibly modified userdefined data */

1630

struct CookieInfo *cookies; /* the cookies, read from files and servers.

1631

NOTE that the 'cookie' field in the

1632

UserDefined struct defines if the "engine"

1633

is to be used or not. */

1634

struct Progress progress; /* for all the progress meter data */

1635

struct UrlState state; /* struct for fields used for state info and

1636

other dynamic purposes */

1637

struct WildcardData wildcard; /* wildcard download state info */

1638

struct PureInfo info; /* stats, reports and info data */

1639

#if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)

1640

iconv_t outbound_cd; /* for translating to the network encoding */

1641

iconv_t inbound_cd; /* for translating from the network encoding */

1642

iconv_t utf8_cd; /* for translating to UTF8 */

1643

#endif /* CURL_DOES_CONVERSIONS && HAVE_ICONV */

1644

unsigned int magic; /* set to a CURLEASY_MAGIC_NUMBER */

1645

};

1646

1647

#define LIBCURL_NAME "libcurl"

1648

1649

#endif /* HEADER_CURL_URLDATA_H */