1

Index: http.c

     2

===================================================================

     3

--- http.c	(revision 848)

     4

+++ http.c	(working copy)

     5

@@ -167,8 +167,10 @@

     6

 static void evhttp_read_header_cb(struct bufferevent *bufev, void *arg);

     7

 static void evhttp_write_cb(struct bufferevent *, void *);

     8

 static void evhttp_error_cb(struct bufferevent *bufev, short what, void *arg);

     9

+

    10

 static int evhttp_decode_uri_internal(const char *uri, size_t length,

    11

     char *ret);

    12

+static void _evhttp_reply_notify (struct evhttp_connection *evcon, void *arg);

    13

    14

 #ifndef HAVE_STRSEP

    15

 /* strsep replacement for platforms that lack it.  Only works if

    16

@@ -293,13 +295,20 @@

    17

    18

 void

    19

 evhttp_write_buffer(struct evhttp_connection *evcon,

    20

-    void (*cb)(struct evhttp_connection *, void *), void *arg)

    21

+    void (*cb)(struct evhttp_connection *, void *), void *arg,

    22

+    size_t threshold)

    23

 {

    24

 	event_debug(("%s: preparing to write buffer\n", __func__));

    25

    26

 	/* Set call back */

    27

 	evcon->cb = cb;

    28

 	evcon->cb_arg = arg;

    29

+    

    30

+    if (threshold > 0) {

    31

+        bufferevent_setwatermark(evcon->bufev, EV_WRITE, threshold, 0);

    32

+    } else {

    33

+        bufferevent_setwatermark(evcon->bufev, EV_WRITE, 0, 0);

    34

+    }

    35

    36

 	bufferevent_disable(evcon->bufev, EV_READ);

    37

 	bufferevent_enable(evcon->bufev, EV_WRITE);

    38

@@ -483,6 +492,17 @@

    39

 	switch (error) {

    40

 	case EVCON_HTTP_TIMEOUT:

    41

 	case EVCON_HTTP_EOF:

    42

+        /*

    43

+         * Fix a bug that caused a nasty infinite-malloc()-and-write() loop.

    44

+         * A write buffer error (e.g. EPIPE) means that we can't write to that 

    45

+         * socket anymore, and evhttp_connection_fail does disable

    46

+         * EV_WRITE|EV_READ for that buffer. However, if we call req->cb, then

    47

+         * that adds a "400 Bad Request" to the buffer, and enables it for

    48

+         * EV_WRITE... which causes evhttp_connection_incoming_fail to be

    49

+         * called again with EVCON_HTTP_BUFFER_ERROR... ended up having to

    50

+         * hard-reset my machine.

    51

+         */

    52

+	case EVCON_HTTP_BUFFER_ERROR:

    53

 		/* 

    54

 		 * these are cases in which we probably should just

    55

 		 * close the connection and not send a reply.  this

    56

@@ -491,7 +511,6 @@

    57

 		 */

    58

 		return (-1);

    59

 	case EVCON_HTTP_INVALID_HEADER:

    60

-	case EVCON_HTTP_BUFFER_ERROR:

    61

 	case EVCON_HTTP_REQUEST_CANCEL:

    62

 	default:	/* xxx: probably should just error on default */

    63

 		/* the callback looks at the uri to determine errors */

    64

@@ -869,7 +888,7 @@

    65

 	/* Create the header from the store arguments */

    66

 	evhttp_make_header(evcon, req);

    67

    68

-	evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);

    69

+	evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL, 0);

    70

 }

    71

    72

 /* Reset our connection state */

    73

@@ -1353,9 +1372,9 @@

    74

 		}

    75

 	}

    76

    77

-	event_debug(("%s: bytes to read: %d (in buffer %ld)\n",

    78

+	event_debug(("%s: bytes to read: %ld (in buffer %ld)\n",

    79

 		__func__, req->ntoread,

    80

-		EVBUFFER_LENGTH(req->evcon->input_buffer)));

    81

+		EVBUFFER_LENGTH(EVBUFFER_INPUT(req->evcon->bufev))));

    82

    83

 	return (0);

    84

 }

    85

@@ -1688,6 +1707,10 @@

    86

    87

 	/* delete possible close detection events */

    88

 	evhttp_connection_stop_detectclose(evcon);

    89

+

    90

+    /* now that the reply was sent, we don't need to abort on connection lost */

    91

+    if (req->abort_cb)

    92

+        evhttp_connection_set_closecb(evcon, NULL, NULL);

    93

    94

 	need_close =

    95

 	    (req->minor == 0 &&

    96

@@ -1753,7 +1776,7 @@

    97

 	/* Adds headers to the response */

    98

 	evhttp_make_header(evcon, req);

    99

   100

-	evhttp_write_buffer(evcon, evhttp_send_done, NULL);

   101

+	evhttp_write_buffer(evcon, evhttp_send_done, NULL, 0);

   102

 }

   103

   104

 void

   105

@@ -1781,7 +1804,7 @@

   106

 		req->chunked = 1;

   107

 	}

   108

 	evhttp_make_header(req->evcon, req);

   109

-	evhttp_write_buffer(req->evcon, NULL, NULL);

   110

+	evhttp_write_buffer(req->evcon, NULL, NULL, 0);

   111

 }

   112

   113

 void

   114

@@ -1796,9 +1819,32 @@

   115

 	if (req->chunked) {

   116

 		evbuffer_add(output, "\r\n", 2);

   117

 	}

   118

-	evhttp_write_buffer(req->evcon, NULL, NULL);

   119

+

   120

+	evhttp_write_buffer(req->evcon, &_evhttp_reply_notify, req, req->write_threshold);

   121

 }

   122

   123

+static void

   124

+_evhttp_reply_notify (struct evhttp_connection *evcon, void *arg)

   125

+{

   126

+    struct evhttp_request *req = arg;

   127

+

   128

+    if (req->write_cb)

   129

+        req->write_cb(req, req->write_cb_arg);

   130

+}

   131

+

   132

+int

   133

+evhttp_set_reply_notify(struct evhttp_request *req, size_t threshold,

   134

+    void (*write_cb)(struct evhttp_request *, void *), void *cb_arg)

   135

+{

   136

+    req->write_threshold = threshold;

   137

+    req->write_cb = write_cb;

   138

+    req->write_cb_arg = cb_arg;

   139

+

   140

+	evhttp_write_buffer(req->evcon, &_evhttp_reply_notify, req, threshold);

   141

+

   142

+    return 0;

   143

+}

   144

+

   145

 void

   146

 evhttp_send_reply_end(struct evhttp_request *req)

   147

 {

   148

@@ -1807,7 +1853,7 @@

   149

   150

 	if (req->chunked) {

   151

 		evbuffer_add(output, "0\r\n\r\n", 5);

   152

-		evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);

   153

+		evhttp_write_buffer(req->evcon, evhttp_send_done, NULL, 0);

   154

 		req->chunked = 0;

   155

 	} else if (EVBUFFER_LENGTH(output) == 0) {

   156

 		/* let the connection know that we are done with the request */

   157

@@ -1819,6 +1865,28 @@

   158

 	}

   159

 }

   160

   161

+void _evhttp_reply_aborted(struct evhttp_connection *evcon, void *arg)

   162

+{

   163

+    struct evhttp_request *req = arg;

   164

+    

   165

+    /* call the callback */

   166

+    req->abort_cb(req, req->abort_cb_arg);

   167

+    

   168

+    /* the request is now aborted, we don't want this called twice */

   169

+    evhttp_connection_set_closecb(evcon, NULL, NULL);

   170

+}

   171

+

   172

+void evhttp_set_reply_abortcb(struct evhttp_request *req,

   173

+    void (*cb)(struct evhttp_request *, void *), void *cb_arg)

   174

+{

   175

+    /* store the cb/arg in req */

   176

+    req->abort_cb = cb;

   177

+    req->abort_cb_arg = cb_arg;

   178

+    

   179

+    /* add a closecb to the connection */

   180

+    evhttp_connection_set_closecb(req->evcon, &_evhttp_reply_aborted, req);

   181

+}

   182

+

   183

 void

   184

 evhttp_response_code(struct evhttp_request *req, int code, const char *reason)

   185

 {

   186

@@ -2448,6 +2516,19 @@

   187

  * Allows for inspection of the request URI

   188

  */

   189

   190

+enum evhttp_cmd_type

   191

+evhttp_request_get_type(struct evhttp_request *req)

   192

+{

   193

+    return req->type;

   194

+}

   195

+

   196

+void

   197

+evhttp_request_get_peer(struct evhttp_request *req,

   198

+    char **address, ev_uint16_t *port)

   199

+{

   200

+    return evhttp_connection_get_peer(req->evcon, address, port);

   201

+}

   202

+

   203

 const char *

   204

 evhttp_request_get_uri(struct evhttp_request *req) {

   205

 	if (req->uri == NULL)

   206

Index: http-internal.h

   207

===================================================================

   208

--- http-internal.h	(revision 848)

   209

+++ http-internal.h	(working copy)

   210

@@ -141,7 +141,8 @@

   211

 void evhttp_make_header(struct evhttp_connection *, struct evhttp_request *);

   212

   213

 void evhttp_write_buffer(struct evhttp_connection *,

   214

-    void (*)(struct evhttp_connection *, void *), void *);

   215

+    void (*)(struct evhttp_connection *, void *), void *,

   216

+    size_t);

   217

   218

 /* response sending HTML the data in the buffer */

   219

 void evhttp_response_code(struct evhttp_request *, int, const char *);

   220

Index: include/event2/http.h

   221

===================================================================

   222

--- include/event2/http.h	(revision 848)

   223

+++ include/event2/http.h	(working copy)

   224

@@ -243,6 +243,7 @@

   225

 */

   226

 void evhttp_send_reply_chunk(struct evhttp_request *req,

   227

     struct evbuffer *databuf);

   228

+

   229

 /**

   230

    Complete a chunked reply.

   231

   232

@@ -250,6 +251,43 @@

   233

 */

   234

 void evhttp_send_reply_end(struct evhttp_request *req);

   235

   236

+/**

   237

+   Used to implement flow control for sending HTTP replies.

   238

+

   239

+   After calling evhttp_send_reply_start, and before calling

   240

+   evhttp_send_reply_end, you may call this function to register a callback

   241

+   that will be fired when the level of the HTTP connection's output buffer is

   242

+   below the given threshold (if the output buffer is empty when this function

   243

+   is called, this will happen on the next event-loop iteration).

   244

+

   245

+   This callback behaves in an edge-triggered way, such that it will only fire

   246

+   once if the otuput buffer's level is below the threshold. It may be called

   247

+   again after the next evhttp_send_reply_chunk call.

   248

+

   249

+   Once evhttp_send_reply_end is called (or an error occurs), the callback is

   250

+   invalidated and not used anymore.

   251

+

   252

+   @param req a request object

   253

+   @param threshold the buffer level to watch for

   254

+   @param write_cb the callback to use

   255

+   @param cb_arg the callback argument

   256

+ 

   257

+*/

   258

+int evhttp_set_reply_notify(struct evhttp_request *req, size_t threshold,

   259

+    void (*write_cb)(struct evhttp_request *, void *), void *cb_arg);

   260

+

   261

+/**

   262

+   Register a callback to get called if the request is aborted due to some

   263

+   reason other than evhttp_send_{reply,error,reply_end}, e.g. the HTTP

   264

+   connection was lost.

   265

+

   266

+   @param req a request object

   267

+   @param cb the callback to use

   268

+   @param cb_arg the callback argument

   269

+*/

   270

+void evhttp_set_reply_abortcb(struct evhttp_request *,

   271

+    void (*)(struct evhttp_request *, void *), void *);

   272

+

   273

 /*

   274

  * Interfaces for making requests

   275

  */

   276

@@ -360,6 +398,11 @@

   277

 void evhttp_cancel_request(struct evhttp_request *req);

   278

   279

   280

+/** Get the request type for this request */

   281

+enum evhttp_cmd_type evhttp_request_get_type(struct evhttp_request *req);

   282

+/** Get the remote address and port this request came from. */

   283

+void evhttp_request_get_peer(struct evhttp_request *req,

   284

+    char **address, ev_uint16_t *port);

   285

 /** Returns the request URI */

   286

 const char *evhttp_request_get_uri(struct evhttp_request *req);

   287

 /** Returns the input headers */

   288

Index: include/event2/http_struct.h

   289

===================================================================

   290

--- include/event2/http_struct.h	(revision 848)

   291

+++ include/event2/http_struct.h	(working copy)

   292

@@ -113,6 +113,19 @@

   293

 	 * the regular callback.

   294

 	 */

   295

 	void (*chunk_cb)(struct evhttp_request *, void *);

   296

+

   297

+    /*

   298

+     * Request reply flow control callback

   299

+     */

   300

+    size_t write_threshold;

   301

+    void (*write_cb)(struct evhttp_request *, void *);

   302

+    void *write_cb_arg;

   303

+

   304

+    /*

   305

+     * Request abort callback

   306

+     */

   307

+    void (*abort_cb)(struct evhttp_request *, void *);

   308

+    void *abort_cb_arg;

   309

 };

   310

   311

 #ifdef __cplusplus

   312

Index: buffer.c

   313

===================================================================

   314

--- buffer.c	(revision 848)

   315

+++ buffer.c	(working copy)

   316

@@ -412,6 +412,9 @@

   317

 	if (size == 0 || size > buf->total_len)

   318

 		return (NULL);

   319

   320

+// XXX: the following will segfault if buf->total_len == 0 && size < -1

   321

+// XXX: the following will return a buffer of arbitrary length if size < -1

   322

+

   323

 	/* No need to pull up anything; the first size bytes are

   324

 	 * already here. */

   325

 	if (chain->off >= size)