cpp-netlib.github.com/0.9.0/reference_http_server.html at master · cpp-netlib/cpp-netlib.github.com

History

767 lines (736 loc) · 48.8 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>HTTP Server API — cpp-netlib v0.9 documentation</title>

var DOCUMENTATION_OPTIONS = {

URL_ROOT: '',

VERSION: '0.9',

COLLAPSE_INDEX: false,

FILE_SUFFIX: '.html',

HAS_SOURCE: true

};

</script>

var _gaq = _gaq || [];

_gaq.push(['_setAccount', 'UA-19815738-1']);

_gaq.push(['_trackPageview']);

(function() {

var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;

ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';

var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);

})();

</script>

</head>

<body>

<h1><a href="index.html">cpp-netlib v0.9 documentation</a></h1>

« <a href="reference_http_response.html" title="HTTP Response">previous</a>

</div>

<h1>HTTP Server API<a class="headerlink" href="#http-server-api" title="Permalink to this headline">¶</a></h1>

<h2>General<a class="headerlink" href="#general" title="Permalink to this headline">¶</a></h2>

<tt class="xref py py-mod docutils literal">cpp-netlib</tt> includes and implements two distinct HTTP server

implementations that you can use and embed in your own applications. Both HTTP

Server implementations:

<li>Cannot be copied. This means you may have to store instances of the HTTP

Server in dynamic memory if you intend to use them as function parameters or

pass them around in smart pointers of by reference.</li>

<li>Assume that requests made are independent of each other. None of the

HTTP Server implementations support request pipelining (yet) so a single

connection only deals with a single request.</li>

<li>Are header-only and are compiled-into your application. Future releases

in case you want to upgrade the implementation you are using in your

application will be distributed as header-only implementations, which means

you have to re-compile your application to use a newer version of the

implementations.</li>

</ul>

</div></blockquote>

The HTTP Servers have different semantics, and in some cases require different

APIs from the supplied template parameters.

</div>

<h2>Implementations<a class="headerlink" href="#implementations" title="Permalink to this headline">¶</a></h2>

There are two different user-facing template classes that differentiate the

<a class="reference internal" href="#synchronous-servers">Synchronous Servers</a> from the <a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a>. Both templates take a

single template parameter named <tt class="docutils literal">Handler</tt> which describes the type of the

Handler function object.

There are two different Handler concepts, one concept for <a class="reference internal" href="#synchronous-servers">Synchronous Servers</a>

and another for <cite>Asynchronous Servers</cite>.

The SynchronusHandler concept for <a class="reference internal" href="#synchronous-servers">Synchronous Servers</a> is described by the

following table:

Legend:

<dd>The Handler type.</dd>

<dd>An instance of H.</dd>

<dd>A type that models the Request Concept.</dd>

<dd>A type that models the Response Concept.</dd>

<dd>An instance of Req.</dd>

<dd>An instance of Res.</dd>

</dl>

</colgroup>

<tr><th class="head">Construct</th>

<th class="head">Return Type</th>

<th class="head">Description</th>

</tr>

</thead>

<td>Handle the request; res is passed in as a

non-const lvalue, which represents the

response to be returned to the client

performing the request.</td>

</tr>

</tbody>

</table>

More information about the internals of the <a class="reference internal" href="#synchronous-servers">Synchronous Servers</a> can be found

in the following section.

The AsynchronousHandler concept for <a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a> is described by the

following table:

Legend:

<dd>The Handler type.</dd>

<dd>An instance of H.</dd>

<dd>A type that models the Request Concept.</dd>

<dt>ConnectionPtr</dt>

<dd>A type that models the Connection Pointer Concept.</dd>

<dd>An instance of Req.</dd>

<dd>An instance of ConncetionPtr.</dd>

</dl>

</colgroup>

<tr><th class="head">Construct</th>

<th class="head">Return Type</th>

<th class="head">Description</th>

</tr>

</thead>

<td>Handle the request; conn is a shared

pointer which exposes functions for

writing to and reading from the connection.</td>

</tr>

</tbody>

</table>

More information about the internals of the <a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a> can be found

in the following section.

</div>

<h2>Synchronous Servers<a class="headerlink" href="#synchronous-servers" title="Permalink to this headline">¶</a></h2>

The synchronous server implementation is represented by the template <tt class="docutils literal">server</tt>

in namespace <tt class="docutils literal">boost::network::http</tt>. The <tt class="docutils literal">server</tt> template takes in a single

template parameter named <tt class="docutils literal">Handler</tt> which models the SynchronousHandler

concept (described above).

An instance of Handler is taken in by reference to the constructor of the HTTP

server. This means the Handler is not copied around and only a single instance

of the handler is used for all connections and requests performed against the

HTTP server.

Warning

It is important to note that the HTTP server does not implement any

locking upon invoking the Handler. In case you have any state in the Handler

that will be associated with the synchronous server, you would have to

implement your own synchronization internal to the Handler implementation.

This matters especially if you run the synchronous server in multiple

threads.

</div>

The general pattern of usage for the HTTP Server template is shown below:

<div class="highlight-c++"><div class="highlight"><pre>struct handler;

typedef boost::network::http::server<handler> http_server;

struct handler {

void operator()(

http_server::request const & req,

http_server::response & res

) {

// do something, and then edit the res object here.

}

};

</pre></div>

</div>

More information about the actual HTTP Server API follows in the next section.

It is important to understand that the HTTP Server is actually embedded in your

application, which means you can expose almost all your application logic

through the Handler type, which you can also initialize appropriately.

<h3>API Documentation<a class="headerlink" href="#api-documentation" title="Permalink to this headline">¶</a></h3>

The following sections assume that the following file has been included:

<div class="highlight-c++"><div class="highlight"><pre>#include <boost/network/include/http/server.hpp>

</pre></div>

</div>

And that the following typedef’s have been put in place:

<div class="highlight-c++"><div class="highlight"><pre>struct handler_type;

typedef boost::network::http::server<handler_type> http_server;

struct handler_type {

void operator()(

http_server::request const & request,

http_server::response & response

) {

// do something here

}

};

</pre></div>

</div>

<h4>Constructor<a class="headerlink" href="#constructor" title="Permalink to this headline">¶</a></h4>

<dt><tt class="docutils literal">http_server(address, port, handler)</tt></dt>

<dd>Construct an HTTP Server instance, passing in the address and port as

<tt class="docutils literal">std::string const &</tt> and handler being of type <tt class="docutils literal">handler_type</tt> but

passed in as an lvalue reference.</dd>

<dt><tt class="docutils literal">template <class ArgPack> client(ArgPack const & args)</tt></dt>

<dd>Pass in an argument pack. See supported parameters in the table below.</dd>

</dl>

</colgroup>

<tr><th class="head">Parameter Name</th>

<th class="head">Description</th>

</tr>

</thead>

<tr><td>_address</td>

<td>string_type</td>

<td>The hostname or IP address from which the server should be bound to. This parameter is required.</td>

</tr>

<td>string_type</td>

<td>The port to which the server should bind and listen to. This parameter is required.</td>

</tr>

<tr><td>_handler</td>

<td><tt class="docutils literal">Handler &</tt></td>

<td>An lvalue reference to an instance of <tt class="docutils literal">Handler</tt>. This parameter is required.</td>

</tr>

<tr><td>_thread_pool</td>

<td><tt class="docutils literal">boost::network::utils::thread_pool &</tt></td>

<td>An lvalue reference to an instance of <tt class="docutils literal">boost::network::utils::thread_pool</tt> – this is the

thread pool from where the handler is invoked. This parameter is only applicable and required

for <tt class="docutils literal">async_server</tt> instances.</td>

</tr>

<tr><td>_io_service</td>

<td><tt class="docutils literal">boost::asio::io_service &</tt></td>

<td>An optional lvalue to an instance of <tt class="docutils literal">boost::asio::io_service</tt> which allows the server to use

an already-constructed <tt class="docutils literal">boost::asio::io_service</tt> instance instead of instantiating one that it

manages.</td>

</tr>

<tr><td>_reuse_address</td>

<td>A boolean that specifies whether to re-use the address and port on which the server will be

bound to. This enables or disables the socket option for listener sockets. The default is

<tt class="docutils literal">false</tt>.</td>

</tr>

<tr><td>_report_aborted</td>

<td>A boolean that specifies whether the listening socket should report aborted connection attempts

to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for

future-proofing the code in case an optional error handler function is supported in later

releases of cpp-netlib. The default is <tt class="docutils literal">false</tt>.</td>

</tr>

<tr><td>_receive_buffer_size</td>

<td>The size of the socket’s receive buffer. The default is defined by Boost.Asio and is

platform-dependent.</td>

</tr>

<tr><td>_send_buffer_size</td>

<td>The size of the socket’s send buffer. The default is defined by Boost.Asio and is

platform-dependent.</td>

</tr>

<tr><td>_receive_low_watermark</td>

<td>The size of the socket’s low watermark for its receive buffer. The default is defined by

Boost.Asio and is platform-dependent.</td>

</tr>

<tr><td>_send_buffer_size</td>

<td>The size of the socket’s send low watermark for its send buffer. The default is defined by

Boost.Asio and is platform-dependent.</td>

</tr>

<tr><td>_non_blocking_io</td>

<td>An optional bool to define whether the socket should use non-blocking I/O in case the platform

supports it. The default is <tt class="docutils literal">true</tt>.</td>

</tr>

<tr><td>_linger</td>

<td>An optional bool to determine whether the socket should linger in case there’s still data to be

sent out at the time of its closing. The default is <tt class="docutils literal">true</tt>.</td>

</tr>

<tr><td>_linger_timeout</td>

<td>An optional int to define the timeout to wait for socket closes before it is set to linger.

The default is <tt class="docutils literal">0</tt>.</td>

</tr>

</tbody>

</table>

To use the above supported named parameters, you’ll have code that looks like the following:

<div class="highlight-c++"><div class="highlight"><pre>using namespace boost::network::http; // parameters are in this namespace

boost::asio::io_service my_io_service;

boost::network::utils::thread_pool pool(2);

handler handler_instance;

async_server<handler> instance(_address="0.0.0.0", _port="80", _handler=handler_instance,

_io_service=my_io_service, _thread_pool=pool,

_reuse_address=true);

instance.run();

</pre></div>

</div>

<h4>Public Members<a class="headerlink" href="#public-members" title="Permalink to this headline">¶</a></h4>

The following definitions assume that a properly constructed <tt class="docutils literal">http_server</tt>

instance has been constructed in the following manner:

<div class="highlight-c++"><div class="highlight"><pre>handler_type handler;

http_server server("127.0.0.1", "8000", handler);

</pre></div>

</div>

<dt><tt class="docutils literal">server.run()</tt></dt>

<dd>Run the HTTP Server event loop. This function can be run on multiple threads

following the example:</dd>

</dl>

<div class="highlight-c++"><div class="highlight"><pre>boost::thread t1(boost::bind(&http_server::run, &server));

boost::thread t2(boost::bind(&http_server::run, &server));

server.run();

t1.join();

t2.join();

</pre></div>

</div>

<dt><tt class="docutils literal">server.stop()</tt></dt>

<dd>Stop the HTTP Server acceptor and wait for all pending requests to finish.</dd>

</dl>

</div>

<h4>Response Object<a class="headerlink" href="#response-object" title="Permalink to this headline">¶</a></h4>

The response object has its own public member functions which can be very

helpful in certain simple situations.

<dt><tt class="docutils literal">response = http_server::response::stock_reply(status, body)</tt></dt>

<dd>Code like the above should go inside the handler’s <tt class="docutils literal">operator()</tt> overload.

The body parameter is an <tt class="docutils literal">std::string</tt>. The status parameter is any of

the following values from the <tt class="docutils literal">http_server::response</tt> enum

<tt class="docutils literal">status_type</tt>:</dd>

</dl>

<div class="highlight-c++"><div class="highlight"><pre>enum status_type {

ok = 200,

created = 201,

accepted = 202,

no_content = 204,

multiple_choices = 300,

moved_permanently = 301,

moved_temporarily = 302,

not_modified = 304,

bad_request = 400,

unauthorized = 401,

forbidden = 403,

not_found = 404,

not_supported = 405,

not_acceptable = 406,

internal_server_error = 500,

not_implemented = 501,

bad_gateway = 502,

service_unavailable = 503

};

</pre></div>

</div>

The response object also has the following publicly accessible member values

which can be directly manipulated by the handler.

</colgroup>

<tr><th class="head">Member Name</th>

<th class="head">Description</th>

</tr>

</thead>

<tr><td>status</td>

<td><tt class="docutils literal">status_type</tt></td>

<td>The HTTP status of the response.</td>

</tr>

<tr><td>headers</td>

<td><tt class="docutils literal">vector<header></tt></td>

<td>Vector of headers. <a class="footnote-reference" href="#id3" id="id1">[1]</a></td>

</tr>

<tr><td>content</td>

<td><tt class="docutils literal">string_type</tt> <a class="footnote-reference" href="#id4" id="id2">[2]</a></td>

<td>The contents of the response.</td>

</tr>

</tbody>

</table>

<tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>A header is a struct of type

<tt class="docutils literal">response_header<http::tags::http_server></tt>. An instance always has the

members <tt class="docutils literal">name</tt> and <tt class="docutils literal">value</tt> both of which are of type <tt class="docutils literal">string_type</tt>.</td></tr>

</tbody>

</table>

<tr><td class="label"><a class="fn-backref" href="#id2">[2]</a></td><td><tt class="docutils literal">string_type</tt> is

<tt class="docutils literal">boost::network::string<http::tags::http_server>::type</tt>.</td></tr>

</tbody>

</table>

</div>

<h2>Asynchronous Servers<a class="headerlink" href="#asynchronous-servers" title="Permalink to this headline">¶</a></h2>

The asynchronous server implementation is significantly different to the

synchronous server implementation in three ways:

<li>The Handler instance is invoked asynchronously. This means the I/O

thread used to handle network-related events are free to handle only the

I/O related events. This enables the server to scale better as to the

number of concurrent connections it can handle.</li>

<li>The Handler is able to schedule asynchronous actions on the thread pool

associated with the server. This allows handlers to perform multiple

asynchronous computations that later on perform writes to the connection.</li>

<li>The Handler is able to control the (asynchronous) writes to and reads from

the HTTP connection. Because the connection is available to the Handler,

that means it can write out chunks of data at a time or stream data through

the connection continuously.</li>

</ol>

</div></blockquote>

The asynchronous server is meant to allow for better scalability in terms of the

number of concurrent connections and for performing asynchronous actions within

the handlers. If your applacation does not need to write out information

asynchronously or perform potentially long computations, then the synchronous

server gives a generally better performance profile than the asynchronous

server.

The asynchronous server implementation is available from a single user-facing

template named <tt class="docutils literal">async_server</tt>. This template takes in a single template

parameter which is the type of the Handler to be called once a request has been

parsed from a connection.

An instance of Handler is taken as a reference to the constructor similar to the

synchronous server implementation.

Warning

The asynchronous server implementation, like the synchronous server

implementation, does not perform any synchronization on the calls to the

Handler invocation. This means if your handler contains or maintains internal

state, you are responsible for implementing your own synchronization on

accesses to the internal state of the Handler.

</div>

The general pattern for using the <tt class="docutils literal">async_server</tt> template is shown below:

<div class="highlight-c++"><div class="highlight"><pre>struct handler;

typedef boost::network::http::async_server<handler> http_server;

struct handler {

void operator()(

http_server::request const & req,

http_server::connection_ptr connection

) {

// handle the request here, and use the connection to

// either read more data or write data out to the client

}

};

</pre></div>

</div>

<h3>API Documentation<a class="headerlink" href="#id5" title="Permalink to this headline">¶</a></h3>

The following sections assume that the following file has been included:

<div class="highlight-c++"><div class="highlight"><pre>#include <boost/network/include/http/server.hpp>

#include <boost/network/utils/thread_pool.hpp>

</pre></div>

</div>

And that the following typedef’s have been put in place:

<div class="highlight-c++"><div class="highlight"><pre>struct handler_type;

typedef boost::network::http::server<handler_type> http_server;

struct handler_type {

void operator()(

http_server::request const & request,

http_server::connection_ptr connection

) {

// do something here

}

};

</pre></div>

</div>

<h4>Constructor<a class="headerlink" href="#id6" title="Permalink to this headline">¶</a></h4>

<dt><tt class="docutils literal">http_server(address, port, handler, thread_pool)</tt></dt>

<dd>Construct an HTTP Server instance, passing in the address and port as

passed in as an lvalue reference. The <tt class="docutils literal">thread_pool</tt> parameter is an

instance of <tt class="docutils literal">boost::network::utils::thread_pool</tt> that has been previously

instantiated.</dd>

</dl>

Note

The <tt class="docutils literal">boost::network::utils::thread_pool</tt> has a single constructor

parameter which is the number of threads to run the thread pool.

</div>

<h4>Public Members<a class="headerlink" href="#id7" title="Permalink to this headline">¶</a></h4>

The following definitions assume that a properly constructed <tt class="docutils literal">http_server</tt>

instance has been constructed in the following manner:

<div class="highlight-c++"><div class="highlight"><pre>handler_type handler;

boost::network::utils::thread_pool thread_pool(2);

</pre></div>

</div>

<dt><tt class="docutils literal">server.run()</tt></dt>

<dd>Run the HTTP Server event loop. This function can be run on multiple threads

following the example:</dd>

</dl>

server.run();

t1.join();

t2.join();

</pre></div>

</div>

<dt><tt class="docutils literal">server.stop()</tt></dt>

<dd>Stop the HTTP Server acceptor and wait for all pending requests to finish.</dd>

</dl>

</div>

<h4>Connection Object<a class="headerlink" href="#connection-object" title="Permalink to this headline">¶</a></h4>

The connection object has its own public member functions which will be the

primary means for reading from and writing to the connection.

<dt><tt class="docutils literal">template <class Range> write(Range range)</tt></dt>

<dd>The connection object exposes a function <tt class="docutils literal">write</tt> that can be given a

parameter that adheres to the <a class="reference external" href="http://www.boost.org/libs/range">Boost.Range</a> <tt class="docutils literal">Single Pass Range</tt> Concept.

The write function, although it looks synchronous, starts of a series of

asynchronous writes to the connection as soon as the range is serialized to

appropriately sized buffers.

To use this in your handler, it would look something like this:

</dd>

</dl>

<div class="highlight-c++"><div class="highlight"><pre>connection->write("Hello, world!");

std::string sample = "I have a string!";

connection->write(sample);

</pre></div>

</div>

<dt><tt class="docutils literal">template <class Range, class Callback> void write(Range range, Callback callback)</tt></dt>

<dd>The connection object also exposes a function <tt class="docutils literal">write</tt> that can be given a

well as a Callback function that returns <tt class="docutils literal">void</tt> and takes a

<tt class="docutils literal">boost::system::error_code</tt> as a parameter. This overload of <tt class="docutils literal">write</tt> is

useful for writing streaming applications that send out chunks of data at a

time, or for writing data that may not all fit in memory right away.</dd>

<dt><tt class="docutils literal">template <class ReadCallback> void read(ReadCallback callback)</tt></dt>

<dd>The connection object has a function <tt class="docutils literal">read</tt> which can be used to read more

information from the connection. This <tt class="docutils literal">read</tt> function takes in a callback

that can be assigned to a <a class="reference external" href="http://www.boost.org/libs/function">Boost.Function</a> with the signature

<tt class="docutils literal">void(input_range,error_code,size_t,connection_ptr)</tt>. The following list

shows what the types actually mean:

<li>input_range – <tt class="docutils literal">boost::iterator_range<char const *></tt> : The range

that denotes the data read from the connection.</li>

<li>error_code – <tt class="docutils literal">boost::system::error_code</tt> : The error code if

there were any errors encountered from the read.</li>

<li>size_t – <tt class="docutils literal">std::size_t</tt> : The number of bytes transferred.</li>

<li>connection_ptr – <tt class="docutils literal">http_server::connection_ptr</tt> : A handle to the

current connection, so that it is kept alive at the time of the read

callback invocation.</li>

</ul>

</div></blockquote>

This interface is useful when doing reads of uploaded data that can be

potentially large and may not fit in memory. The read handler is then

responsible for dealing with the chunks of data available from the

connection.

</dd>

<dt><tt class="docutils literal">void set_status(status_t new_status)</tt></dt>

<dd>The <tt class="docutils literal">set_status</tt> function takes a parameter of type <tt class="docutils literal">status_t</tt> which is

an enum type nested in <tt class="docutils literal">http_status::connection</tt> which is given in the

following code listing.</dd>

</dl>

<div class="highlight-c++"><div class="highlight"><pre>enum status_t {

ok = 200

, created = 201

, accepted = 202

, no_content = 204

, multiple_choices = 300

, moved_permanently = 301

, moved_temporarily = 302

, not_modified = 304

, bad_request = 400

, unauthorized = 401

, forbidden = 403

, not_found = 404

, not_supported = 405

, not_acceptable = 406

, internal_server_error = 500

, not_implemented = 501

, bad_gateway = 502

, service_unavailable = 503

};

</pre></div>

</div>

Note

You may set and re-set the status several times as long as you have

not set the headers or sent data through the connection. If you do this after

data has already been set, the function will throw an instance of

<tt class="docutils literal">std::logic_error</tt>.

</div>

<dt><tt class="docutils literal">template <class Range> void set_headers(Range range)</tt></dt>

<dd>The <tt class="docutils literal">set_headers</tt> function takes a Single Pass Range of

<tt class="docutils literal">boost::network::http::response_header<http::tags::http_async_server></tt>

instances and linearizes them to a buffer with at most

<tt class="docutils literal">BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE</tt> and

immediately schedules an asynchronous write once that is done.

The function throws an instance of <tt class="docutils literal">std::logic_error</tt> if you try to set

the headers for a connection more than once.

</dd>

</dl>

</div>

<h3><a href="index.html">Table Of Contents</a></h3>

<ul>

<li><a class="reference internal" href="#">HTTP Server API</a><ul>

<li><a class="reference internal" href="#general">General</a></li>

<li><a class="reference internal" href="#implementations">Implementations</a></li>

<li><a class="reference internal" href="#synchronous-servers">Synchronous Servers</a><ul>

<li><a class="reference internal" href="#api-documentation">API Documentation</a><ul>

<li><a class="reference internal" href="#constructor">Constructor</a></li>

<li><a class="reference internal" href="#public-members">Public Members</a></li>

<li><a class="reference internal" href="#response-object">Response Object</a></li>

</ul>

</li>

</ul>

</li>

<li><a class="reference internal" href="#asynchronous-servers">Asynchronous Servers</a><ul>

<li><a class="reference internal" href="#id5">API Documentation</a><ul>

<li><a class="reference internal" href="#id6">Constructor</a></li>

<li><a class="reference internal" href="#id7">Public Members</a></li>

<li><a class="reference internal" href="#connection-object">Connection Object</a></li>

</ul>

</li>

</ul>

</li>

</ul>

</li>

</ul>

<h3>Browse</h3>

<ul>

<li>Prev: <a href="reference_http_response.html">HTTP Response</a></li>

<li>Next: <a href="references.html">References</a></li>

</ul>

<ul>

<li>

<a href="index.html">cpp-netlib v0.9 documentation</a>

<ul><li><a href="reference.html">Reference Manual</a>

<ul><li>HTTP Server API</li></ul>

</li></ul>

</li>

</ul>

<li><a href="_sources/reference_http_server.txt"

rel="nofollow">Show Source</a></li>

</ul>

<h3>Quick search</h3>

</form>

Enter search terms or a module, class or function name.

</div>

</div>

« <a href="reference_http_response.html" title="HTTP Response">previous</a>

</div>

</div>

documentation automatically generated by <a href="http://sphinx.pocoo.org">Sphinx</a> | style mostly stolen from <a href="http://lettuce.it">lettuce.it</a>

| background image attributed to <a href="http://www.flickr.com/photos/OrangeSmell">OrangeSmell</a>

</div>

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

reference_http_server.html

Latest commit

History

reference_http_server.html

File metadata and controls