2 * @file sipe-http-transport.c
6 * Copyright (C) 2013 SIPE Project <http://sipe.sourceforge.net/>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * SIPE HTTP transport layer implementation
26 * - connection handling: opening, closing, timeout
27 * - interface to backend: sending & receiving of raw messages
28 * - request queue pulling
37 #include "sipe-backend.h"
38 #include "sipe-common.h"
39 #include "sipe-core.h"
40 #include "sipe-core-private.h"
41 #include "sipe-http.h"
42 #include "sipe-schedule.h"
43 #include "sipe-utils.h"
45 #define _SIPE_HTTP_PRIVATE_IF_REQUEST
46 #include "sipe-http-request.h"
47 #define _SIPE_HTTP_PRIVATE_IF_TRANSPORT
48 #include "sipe-http-transport.h"
50 #define SIPE_HTTP_CONNECTION ((struct sipe_http_connection *) connection->user_data)
51 #define SIPE_HTTP_CONNECTION_PRIVATE ((struct sipe_http_connection *) conn_public)
52 #define SIPE_HTTP_CONNECTION_PUBLIC ((struct sipe_http_connection_public *) conn)
54 #define SIPE_HTTP_TIMEOUT_ACTION "<+http-timeout>"
55 #define SIPE_HTTP_DEFAULT_TIMEOUT 60 /* in seconds */
57 struct sipe_http_connection
{
58 struct sipe_http_connection_public
public;
60 struct sipe_transport_connection
*connection
;
63 time_t timeout
; /* in seconds from epoch */
67 GHashTable
*connections
;
69 time_t next_timeout
; /* in seconds from epoch, 0 if timer isn't running */
70 gboolean shutting_down
;
73 static gint
timeout_compare(gconstpointer a
,
75 SIPE_UNUSED_PARAMETER gpointer user_data
)
77 return(((struct sipe_http_connection
*) a
)->timeout
-
78 ((struct sipe_http_connection
*) b
)->timeout
);
81 static void sipe_http_transport_free(gpointer data
)
83 struct sipe_http_connection
*conn
= data
;
84 struct sipe_http
*http
= conn
->public.sipe_private
->http
;
86 SIPE_DEBUG_INFO("sipe_http_transport_free: destroying connection '%s'",
90 sipe_backend_transport_disconnect(conn
->connection
);
91 conn
->connection
= NULL
;
93 g_queue_remove(http
->timeouts
, conn
);
95 sipe_http_request_shutdown(SIPE_HTTP_CONNECTION_PUBLIC
);
97 g_free(conn
->public.host
);
99 g_free(conn
->host_port
);
103 static void sipe_http_transport_drop(struct sipe_http
*http
,
104 struct sipe_http_connection
*conn
,
105 const gchar
*message
)
107 SIPE_DEBUG_INFO("sipe_http_transport_drop: dropping connection '%s': %s",
109 message
? message
: "REASON UNKNOWN");
111 /* this triggers sipe_http_transport_new */
112 g_hash_table_remove(http
->connections
,
116 static void start_timer(struct sipe_core_private
*sipe_private
,
117 time_t current_time
);
118 static void sipe_http_transport_timeout(struct sipe_core_private
*sipe_private
,
121 struct sipe_http
*http
= sipe_private
->http
;
122 struct sipe_http_connection
*conn
= data
;
123 time_t current_time
= time(NULL
);
125 /* timer has expired */
126 http
->next_timeout
= 0;
129 sipe_http_transport_drop(http
, conn
, "timeout");
130 /* conn is no longer valid */
132 /* is there another active connection? */
133 conn
= g_queue_peek_head(http
->timeouts
);
137 /* restart timer for next connection */
138 if (conn
->timeout
> current_time
) {
139 start_timer(sipe_private
, current_time
);
143 /* next connection timed-out too, loop around */
147 static void start_timer(struct sipe_core_private
*sipe_private
,
150 struct sipe_http
*http
= sipe_private
->http
;
151 struct sipe_http_connection
*conn
= g_queue_peek_head(http
->timeouts
);
153 http
->next_timeout
= conn
->timeout
;
154 sipe_schedule_seconds(sipe_private
,
155 SIPE_HTTP_TIMEOUT_ACTION
,
157 http
->next_timeout
- current_time
,
158 sipe_http_transport_timeout
,
162 static void sipe_http_transport_update_timeout_queue(struct sipe_http_connection
*conn
,
165 struct sipe_core_private
*sipe_private
= conn
->public.sipe_private
;
166 struct sipe_http
*http
= sipe_private
->http
;
167 GQueue
*timeouts
= http
->timeouts
;
168 time_t current_time
= time(NULL
);
170 /* is this connection at head of queue? */
171 gboolean update
= (conn
== g_queue_peek_head(timeouts
));
173 /* update timeout queue */
175 g_queue_remove(timeouts
, conn
);
177 conn
->timeout
= current_time
+ SIPE_HTTP_DEFAULT_TIMEOUT
;
178 g_queue_sort(timeouts
,
183 /* update timer if necessary */
185 sipe_schedule_cancel(sipe_private
, SIPE_HTTP_TIMEOUT_ACTION
);
186 if (g_queue_is_empty(timeouts
)) {
187 http
->next_timeout
= 0;
189 start_timer(sipe_private
, current_time
);
194 gboolean
sipe_http_shutting_down(struct sipe_core_private
*sipe_private
)
196 struct sipe_http
*http
= sipe_private
->http
;
197 /* We need to return FALSE in case HTTP stack isn't initialized yet */
200 return(http
->shutting_down
);
203 void sipe_http_free(struct sipe_core_private
*sipe_private
)
205 struct sipe_http
*http
= sipe_private
->http
;
209 /* HTTP stack is shutting down: reject all new requests */
210 http
->shutting_down
= TRUE
;
212 sipe_schedule_cancel(sipe_private
, SIPE_HTTP_TIMEOUT_ACTION
);
213 g_hash_table_destroy(http
->connections
);
214 g_queue_free(http
->timeouts
);
216 sipe_private
->http
= NULL
;
219 static void sipe_http_init(struct sipe_core_private
*sipe_private
)
221 struct sipe_http
*http
;
222 if (sipe_private
->http
)
225 sipe_private
->http
= http
= g_new0(struct sipe_http
, 1);
226 http
->connections
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
228 sipe_http_transport_free
);
229 http
->timeouts
= g_queue_new();
232 static void sipe_http_transport_connected(struct sipe_transport_connection
*connection
)
234 struct sipe_http_connection
*conn
= SIPE_HTTP_CONNECTION
;
235 struct sipe_core_private
*sipe_private
= conn
->public.sipe_private
;
236 struct sipe_http
*http
= sipe_private
->http
;
237 time_t current_time
= time(NULL
);
239 SIPE_DEBUG_INFO("sipe_http_transport_connected: %s", conn
->host_port
);
240 conn
->public.connected
= TRUE
;
242 /* add active connection to timeout queue */
243 conn
->timeout
= current_time
+ SIPE_HTTP_DEFAULT_TIMEOUT
;
244 g_queue_insert_sorted(http
->timeouts
,
249 /* start timeout timer if necessary */
250 if (http
->next_timeout
== 0)
251 start_timer(sipe_private
, current_time
);
253 sipe_http_request_next(SIPE_HTTP_CONNECTION_PUBLIC
);
256 static void sipe_http_transport_input(struct sipe_transport_connection
*connection
)
258 struct sipe_http_connection
*conn
= SIPE_HTTP_CONNECTION
;
259 char *current
= connection
->buffer
;
261 /* according to the RFC remove CRLF at the beginning */
262 while (*current
== '\r' || *current
== '\n') {
265 if (current
!= connection
->buffer
)
266 sipe_utils_shrink_buffer(connection
, current
);
268 if ((current
= strstr(connection
->buffer
, "\r\n\r\n")) != NULL
) {
274 msg
= sipmsg_parse_header(connection
->buffer
);
276 /* restore header for next try */
281 /* HTTP/1.1 Transfer-Encoding: chunked */
282 if (msg
->bodylen
== SIPMSG_BODYLEN_CHUNKED
) {
283 gchar
*start
= current
+ 2;
284 GSList
*chunks
= NULL
;
285 gboolean incomplete
= TRUE
;
288 while (strlen(start
) > 0) {
290 guint length
= g_ascii_strtoll(start
, &tmp
, 16);
298 if ((length
== 0) && (start
== tmp
))
300 msg
->bodylen
+= length
;
302 /* Chunk header not finished yet */
303 tmp
= strstr(tmp
, "\r\n");
307 /* Chunk not finished yet */
309 remainder
= connection
->buffer_used
- (tmp
- connection
->buffer
);
310 if (remainder
< length
+ 2)
314 start
= tmp
+ length
+ 2;
318 gchar
*dummy
= g_malloc(msg
->bodylen
+ 1);
320 GSList
*entry
= chunks
;
324 memcpy(p
, chunk
->start
, chunk
->length
);
331 sipe_utils_message_debug("HTTP",
337 sipe_utils_shrink_buffer(connection
,
344 /* Append completed chunk */
345 chunk
= g_new0(struct _chunk
, 1);
346 chunk
->length
= length
;
348 chunks
= g_slist_append(chunks
, chunk
);
352 sipe_utils_slist_free_full(chunks
, g_free
);
355 /* restore header for next try */
362 guint remainder
= connection
->buffer_used
- (current
+ 2 - connection
->buffer
);
364 if (remainder
>= (guint
) msg
->bodylen
) {
365 char *dummy
= g_malloc(msg
->bodylen
+ 1);
367 memcpy(dummy
, current
, msg
->bodylen
);
368 dummy
[msg
->bodylen
] = '\0';
370 current
+= msg
->bodylen
;
371 sipe_utils_message_debug("HTTP",
375 sipe_utils_shrink_buffer(connection
, current
);
377 SIPE_DEBUG_INFO("sipe_http_transport_input: body too short (%d < %d, strlen %" G_GSIZE_FORMAT
") - ignoring message",
378 remainder
, msg
->bodylen
, strlen(connection
->buffer
));
380 /* restore header for next try */
387 sipe_http_request_response(SIPE_HTTP_CONNECTION_PUBLIC
, msg
);
388 next
= sipe_http_request_pending(SIPE_HTTP_CONNECTION_PUBLIC
);
390 if (sipe_strcase_equal(sipmsg_find_header(msg
, "Connection"), "close")) {
391 /* drop backend connection */
392 SIPE_DEBUG_INFO("sipe_http_transport_input: server requested close '%s'",
394 sipe_backend_transport_disconnect(conn
->connection
);
395 conn
->connection
= NULL
;
396 conn
->public.connected
= FALSE
;
398 /* if we have pending requests we need to trigger re-connect */
400 sipe_http_transport_new(conn
->public.sipe_private
,
405 /* trigger sending of next pending request */
406 sipe_http_request_next(SIPE_HTTP_CONNECTION_PUBLIC
);
413 static void sipe_http_transport_error(struct sipe_transport_connection
*connection
,
416 struct sipe_http_connection
*conn
= SIPE_HTTP_CONNECTION
;
417 sipe_http_transport_drop(conn
->public.sipe_private
->http
,
420 /* conn is no longer valid */
423 struct sipe_http_connection_public
*sipe_http_transport_new(struct sipe_core_private
*sipe_private
,
424 const gchar
*host_in
,
427 struct sipe_http
*http
;
428 struct sipe_http_connection
*conn
= NULL
;
429 /* host name matching should be case insensitive */
430 gchar
*host
= g_ascii_strdown(host_in
, -1);
431 gchar
*host_port
= g_strdup_printf("%s:%" G_GUINT32_FORMAT
, host
, port
);
433 sipe_http_init(sipe_private
);
435 http
= sipe_private
->http
;
436 if (http
->shutting_down
) {
437 SIPE_DEBUG_ERROR("sipe_http_transport_new: new connection requested during shutdown: THIS SHOULD NOT HAPPEN! Debugging information:\n"
438 "Host/Port: %s", host_port
);
440 conn
= g_hash_table_lookup(http
->connections
, host_port
);
443 /* re-establishing connection */
444 if (!conn
->connection
) {
445 SIPE_DEBUG_INFO("sipe_http_transport_new: re-establishing %s", host_port
);
447 /* will be re-inserted after connect */
448 sipe_http_transport_update_timeout_queue(conn
, TRUE
);
453 SIPE_DEBUG_INFO("sipe_http_transport_new: new %s", host_port
);
455 conn
= g_new0(struct sipe_http_connection
, 1);
457 conn
->public.sipe_private
= sipe_private
;
458 conn
->public.host
= g_strdup(host
);
459 conn
->public.port
= port
;
461 conn
->host_port
= host_port
;
463 g_hash_table_insert(http
->connections
,
466 host_port
= NULL
; /* conn_private takes ownership of the key */
469 if (!conn
->connection
) {
470 sipe_connect_setup setup
= {
471 SIPE_TRANSPORT_TLS
, /* TBD: we only support TLS for now */
475 sipe_http_transport_connected
,
476 sipe_http_transport_input
,
477 sipe_http_transport_error
480 conn
->public.connected
= FALSE
;
481 conn
->connection
= sipe_backend_transport_connect(SIPE_CORE_PUBLIC
,
488 return(SIPE_HTTP_CONNECTION_PUBLIC
);
491 void sipe_http_transport_send(struct sipe_http_connection_public
*conn_public
,
495 struct sipe_http_connection
*conn
= SIPE_HTTP_CONNECTION_PRIVATE
;
496 GString
*message
= g_string_new(header
);
498 g_string_append_printf(message
, "\r\n%s", body
? body
: "");
500 sipe_utils_message_debug("HTTP", message
->str
, NULL
, TRUE
);
501 sipe_backend_transport_message(conn
->connection
, message
->str
);
502 g_string_free(message
, TRUE
);
504 sipe_http_transport_update_timeout_queue(conn
, FALSE
);