src/core/sipe-http-request.c

   1 /**
   2  * @file sipe-http-request.c
   3 *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2013 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  *
   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.
  13  *
  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.
  18  *
  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
  22  *
  23  *
  24  * SIPE HTTP request layer implementation
  25  *
  26  *  - request handling: creation, parameters, deletion, cancelling
  27  *  - session handling: creation, closing
  28  *  - client authorization handling
  29  *  - connection request queue handling
  30  *  - compile HTTP header contents and hand-off to transport layer
  31  *  - process HTTP response and hand-off to user callback
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include <string.h>
  39
  40 #include <glib.h>
  41
  42 #include "sipmsg.h"
  43 #include "sip-sec.h"
  44 #include "sipe-backend.h"
  45 #include "sipe-core.h"
  46 #include "sipe-core-private.h"
  47 #include "sipe-http.h"
  48
  49 #define _SIPE_HTTP_PRIVATE_IF_REQUEST
  50 #include "sipe-http-request.h"
  51 #define _SIPE_HTTP_PRIVATE_IF_TRANSPORT
  52 #include "sipe-http-transport.h"
  53
  54 struct sipe_http_session {
  55         gchar *cookie; /* extremely simplistic cookie jar :-) */
  56 };
  57
  58 struct sipe_http_request {
  59         struct sipe_http_connection_public *connection;
  60
  61         struct sipe_http_session *session;
  62
  63         gchar *path;
  64         gchar *headers;
  65         gchar *body;           /* NULL for GET */
  66         gchar *content_type;   /* NULL if body == NULL */
  67         gchar *authorization;
  68
  69         const gchar *domain;   /* not copied */
  70         const gchar *user;     /* not copied */
  71         const gchar *password; /* not copied */
  72
  73         sipe_http_response_callback *cb;
  74         gpointer cb_data;
  75
  76         guint32 flags;
  77 };
  78
  79 #define SIPE_HTTP_REQUEST_FLAG_FIRST    0x00000001
  80 #define SIPE_HTTP_REQUEST_FLAG_REDIRECT 0x00000002
  81 #define SIPE_HTTP_REQUEST_FLAG_AUTHDATA 0x00000004
  82
  83 static void sipe_http_request_free(struct sipe_core_private *sipe_private,
  84                                    struct sipe_http_request *req)
  85 {
  86         if (req->cb)
  87                 /* Callback: aborted */
  88                 (*req->cb)(sipe_private, 0, NULL, NULL, req->cb_data);
  89         g_free(req->path);
  90         g_free(req->headers);
  91         g_free(req->body);
  92         g_free(req->content_type);
  93         g_free(req->authorization);
  94         g_free(req);
  95 }
  96
  97 static void sipe_http_request_send(struct sipe_http_connection_public *conn_public)
  98 {
  99         struct sipe_http_request *req = conn_public->pending_requests->data;
 100         gchar *header;
 101         gchar *content = NULL;
 102         gchar *cookie  = NULL;
 103
 104         if (req->body)
 105                 content = g_strdup_printf("Content-Length: %" G_GSIZE_FORMAT "\r\n"
 106                                           "Content-Type: %s\r\n",
 107                                           strlen(req->body),
 108                                           req->content_type);
 109
 110         if (req->session && req->session->cookie)
 111                 cookie = g_strdup_printf("Cookie: %s\r\n", req->session->cookie);
 112
 113         header = g_strdup_printf("%s /%s HTTP/1.1\r\n"
 114                                  "Host: %s\r\n"
 115                                  "User-Agent: Sipe/" PACKAGE_VERSION "\r\n"
 116                                  "%s%s%s%s",
 117                                  content ? "POST" : "GET",
 118                                  req->path,
 119                                  conn_public->host,
 120                                  req->authorization ? req->authorization : "",
 121                                  req->headers ? req->headers : "",
 122                                  cookie ? cookie : "",
 123                                  content ? content : "");
 124         g_free(cookie);
 125         g_free(content);
 126
 127         /* only use authorization once */
 128         g_free(req->authorization);
 129         req->authorization = NULL;
 130
 131         sipe_http_transport_send(conn_public,
 132                                  header,
 133                                  req->body);
 134         g_free(header);
 135 }
 136
 137 gboolean sipe_http_request_pending(struct sipe_http_connection_public *conn_public)
 138 {
 139         return(conn_public->pending_requests != NULL);
 140 }
 141
 142 void sipe_http_request_next(struct sipe_http_connection_public *conn_public)
 143 {
 144         sipe_http_request_send(conn_public);
 145 }
 146
 147 static void sipe_http_request_enqueue(struct sipe_core_private *sipe_private,
 148                                       struct sipe_http_request *req,
 149                                       const struct sipe_http_parsed_uri *parsed_uri)
 150 {
 151         struct sipe_http_connection_public *conn_public;
 152
 153         req->path       = g_strdup(parsed_uri->path);
 154         req->connection = conn_public = sipe_http_transport_new(sipe_private,
 155                                                                 parsed_uri->host,
 156                                                                 parsed_uri->port);
 157         if (!sipe_http_request_pending(conn_public))
 158                 req->flags |= SIPE_HTTP_REQUEST_FLAG_FIRST;
 159
 160         conn_public->pending_requests = g_slist_append(conn_public->pending_requests,
 161                                                        req);
 162 }
 163
 164 /* TRUE indicates failure */
 165 static gboolean sipe_http_request_response_redirection(struct sipe_core_private *sipe_private,
 166                                                    struct sipe_http_request *req,
 167                                                    struct sipmsg *msg)
 168 {
 169         const gchar *location = sipmsg_find_header(msg, "Location");
 170         gboolean failed = TRUE;
 171
 172         if (location) {
 173                 struct sipe_http_parsed_uri *parsed_uri = sipe_http_parse_uri(location);
 174
 175                 if (parsed_uri) {
 176                         /* remove request from old connection */
 177                         struct sipe_http_connection_public *conn_public = req->connection;
 178                         conn_public->pending_requests = g_slist_remove(conn_public->pending_requests,
 179                                                                        req);
 180
 181                         /* free old request data */
 182                         g_free(req->path);
 183                         req->flags &= ~SIPE_HTTP_REQUEST_FLAG_FIRST;
 184
 185                         /* resubmit request on other connection */
 186                         sipe_http_request_enqueue(sipe_private, req, parsed_uri);
 187                         failed = FALSE;
 188
 189                         sipe_http_parsed_uri_free(parsed_uri);
 190                 } else
 191                         SIPE_DEBUG_INFO("sipe_http_request_response_redirection: invalid redirection to '%s'",
 192                                         location);
 193         } else
 194                 SIPE_DEBUG_INFO_NOFORMAT("sipe_http_request_response_redirection: no URL found?!?");
 195
 196         return(failed);
 197 }
 198
 199 /* TRUE indicates failure */
 200 static gboolean sipe_http_request_response_unauthorized(struct sipe_core_private *sipe_private,
 201                                                         struct sipe_http_request *req,
 202                                                         struct sipmsg *msg)
 203 {
 204         const gchar *header = NULL;
 205         const gchar *name;
 206         guint type;
 207         gboolean failed = TRUE;
 208
 209 #if defined(HAVE_LIBKRB5) || defined(HAVE_SSPI)
 210 #define DEBUG_STRING "NTLM and Negotiate authentications are"
 211         /* Use "Negotiate" unless the user requested "NTLM" */
 212         if (sipe_private->authentication_type != SIPE_AUTHENTICATION_TYPE_NTLM)
 213                 header = sipmsg_find_auth_header(msg, "Negotiate");
 214         if (header) {
 215                 type   = SIPE_AUTHENTICATION_TYPE_NEGOTIATE;
 216                 name   = "Negotiate";
 217         } else
 218 #else
 219 #define DEBUG_STRING "NTLM authentication is"
 220 #endif
 221         {
 222                 header = sipmsg_find_auth_header(msg, "NTLM");
 223                 type   = SIPE_AUTHENTICATION_TYPE_NTLM;
 224                 name   = "NTLM";
 225         }
 226
 227         if (header) {
 228                 struct sipe_http_connection_public *conn_public = req->connection;
 229
 230                 if (!conn_public->context) {
 231                         gboolean valid = req->flags & SIPE_HTTP_REQUEST_FLAG_AUTHDATA;
 232                         conn_public->context = sip_sec_create_context(type,
 233                                                                       !valid, /* Single Sign-On flag */
 234                                                                       TRUE,   /* connection-based for HTTP */
 235                                                                       valid ? req->domain   : NULL,
 236                                                                       valid ? req->user     : NULL,
 237                                                                       valid ? req->password : NULL);
 238                 }
 239
 240
 241                 if (conn_public->context) {
 242                         gchar **parts = g_strsplit(header, " ", 0);
 243                         gchar *spn    = g_strdup_printf("HTTP/%s", conn_public->host);
 244                         gchar *token;
 245
 246                         SIPE_DEBUG_INFO("sipe_http_request_response_unauthorized: init context target '%s' token '%s'",
 247                                         spn, parts[1] ? parts[1] : "<NULL>");
 248
 249                         if (sip_sec_init_context_step(conn_public->context,
 250                                                       spn,
 251                                                       parts[1],
 252                                                       &token,
 253                                                       NULL)) {
 254
 255                                 /* generate authorization header */
 256                                 req->authorization = g_strdup_printf("Authorization: %s %s\r\n",
 257                                                                      name,
 258                                                                      token ? token : "");
 259                                 g_free(token);
 260
 261                                 /*
 262                                  * Keep the request in the queue. As it is at
 263                                  * the head it will be pulled automatically
 264                                  * by the transport layer after returning.
 265                                  */
 266                                 failed = FALSE;
 267
 268                         } else
 269                                 SIPE_DEBUG_INFO_NOFORMAT("sipe_http_request_response_unauthorized: security context init step failed");
 270
 271                         g_free(spn);
 272                         g_strfreev(parts);
 273                 } else
 274                         SIPE_DEBUG_INFO_NOFORMAT("sipe_http_request_response_unauthorized: security context creation failed");
 275         } else
 276                 SIPE_DEBUG_INFO_NOFORMAT("sipe_http_request_response_unauthorized: only " DEBUG_STRING " supported");
 277
 278         return(failed);
 279 }
 280
 281 static void sipe_http_request_response_callback(struct sipe_core_private *sipe_private,
 282                                                 struct sipe_http_request *req,
 283                                                 struct sipmsg *msg)
 284 {
 285         const gchar *hdr;
 286
 287         /* Set-Cookie: RMID=732423sdfs73242; expires=Fri, 31-Dec-2010 23:59:59 GMT; path=/; domain=.example.net */
 288         if (req->session &&
 289             ((hdr = sipmsg_find_header(msg, "Set-Cookie")) != NULL)) {
 290                 gchar **parts, **current;
 291                 const gchar *part;
 292                 gchar *new = NULL;
 293
 294                 g_free(req->session->cookie);
 295                 req->session->cookie = NULL;
 296
 297                 current = parts = g_strsplit(hdr, ";", 0);
 298                 while ((part = *current++) != NULL) {
 299                         /* strip these parts from cookie */
 300                         if (!(strstr(part, "path=")    ||
 301                               strstr(part, "domain=")  ||
 302                               strstr(part, "expires=") ||
 303                               strstr(part, "secure"))) {
 304                                 gchar *tmp = new;
 305                                 new = new ?
 306                                         g_strconcat(new, ";", part, NULL) :
 307                                         g_strdup(part);
 308                                 g_free(tmp);
 309                         }
 310                 }
 311                 g_strfreev(parts);
 312
 313                 if (new) {
 314                         req->session->cookie = new;
 315                         SIPE_DEBUG_INFO("sipe_http_request_response_callback: cookie: %s", new);
 316                 }
 317         }
 318
 319         /* Callback: success */
 320         (*req->cb)(sipe_private,
 321                    msg->response,
 322                    msg->headers,
 323                    msg->body,
 324                    req->cb_data);
 325
 326         /* remove completed request */
 327         sipe_http_request_cancel(req);
 328 }
 329
 330 void sipe_http_request_response(struct sipe_http_connection_public *conn_public,
 331                                 struct sipmsg *msg)
 332 {
 333         struct sipe_core_private *sipe_private = conn_public->sipe_private;
 334         struct sipe_http_request *req = conn_public->pending_requests->data;
 335         gboolean failed;
 336
 337         if ((req->flags & SIPE_HTTP_REQUEST_FLAG_REDIRECT)   &&
 338             (msg->response >= SIPE_HTTP_STATUS_REDIRECTION)  &&
 339             (msg->response <  SIPE_HTTP_STATUS_CLIENT_ERROR)) {
 340                 failed = sipe_http_request_response_redirection(sipe_private,
 341                                                                 req,
 342                                                                 msg);
 343
 344         } else if (msg->response == SIPE_HTTP_STATUS_CLIENT_UNAUTHORIZED) {
 345                 failed = sipe_http_request_response_unauthorized(sipe_private,
 346                                                                  req,
 347                                                                  msg);
 348
 349         } else {
 350                 /* All other cases are passed on to the user */
 351                 sipe_http_request_response_callback(sipe_private, req, msg);
 352
 353                 /* req is no longer valid */
 354                 failed = FALSE;
 355         }
 356
 357         if (failed) {
 358                 /* Callback: request failed */
 359                 (*req->cb)(sipe_private, 0, NULL, NULL, req->cb_data);
 360
 361                 /* remove failed request */
 362                 sipe_http_request_cancel(req);
 363         }
 364 }
 365
 366 void sipe_http_request_shutdown(struct sipe_http_connection_public *conn_public)
 367 {
 368         if (conn_public->pending_requests) {
 369                 GSList *entry = conn_public->pending_requests;
 370                 while (entry) {
 371                         sipe_http_request_free(conn_public->sipe_private,
 372                                                entry->data);
 373                         entry = entry->next;
 374                 }
 375                 g_slist_free(conn_public->pending_requests);
 376                 conn_public->pending_requests = NULL;
 377         }
 378
 379         if (conn_public->context) {
 380                 sip_sec_destroy_context(conn_public->context);
 381                 conn_public->context = NULL;
 382         }
 383 }
 384
 385 struct sipe_http_request *sipe_http_request_new(struct sipe_core_private *sipe_private,
 386                                                 const struct sipe_http_parsed_uri *parsed_uri,
 387                                                 const gchar *headers,
 388                                                 const gchar *body,
 389                                                 const gchar *content_type,
 390                                                 sipe_http_response_callback *callback,
 391                                                 gpointer callback_data)
 392 {
 393         struct sipe_http_request *req;
 394         if (!parsed_uri)
 395                 return(NULL);
 396
 397         req          = g_new0(struct sipe_http_request, 1);
 398         req->flags   = 0;
 399         req->cb      = callback;
 400         req->cb_data = callback_data;
 401         if (headers)
 402                 req->headers      = g_strdup(headers);
 403         if (body) {
 404                 req->body         = g_strdup(body);
 405                 req->content_type = g_strdup(content_type);
 406         }
 407
 408         /* default authentication */
 409         if (!SIPE_CORE_PRIVATE_FLAG_IS(SSO))
 410                 sipe_http_request_authentication(req,
 411                                                  sipe_private->authdomain,
 412                                                  sipe_private->authuser,
 413                                                  sipe_private->password);
 414
 415         sipe_http_request_enqueue(sipe_private, req, parsed_uri);
 416
 417         return(req);
 418 }
 419
 420 void sipe_http_request_ready(struct sipe_http_request *request)
 421 {
 422         struct sipe_http_connection_public *conn_public = request->connection;
 423
 424         /* pass first request on already opened connection through directly */
 425         if ((request->flags & SIPE_HTTP_REQUEST_FLAG_FIRST) &&
 426             conn_public->connected)
 427                 sipe_http_request_send(conn_public);
 428 }
 429
 430 struct sipe_http_session *sipe_http_session_start(void)
 431 {
 432         return(g_new0(struct sipe_http_session, 1));
 433 }
 434
 435 void sipe_http_session_close(struct sipe_http_session *session)
 436 {
 437         if (session) {
 438                 g_free(session->cookie);
 439                 g_free(session);
 440         }
 441 }
 442
 443 void sipe_http_request_cancel(struct sipe_http_request *request)
 444 {
 445         struct sipe_http_connection_public *conn_public = request->connection;
 446         conn_public->pending_requests = g_slist_remove(conn_public->pending_requests,
 447                                                        request);
 448
 449         /* cancelled by requester, don't use callback */
 450         request->cb = NULL;
 451
 452         sipe_http_request_free(conn_public->sipe_private, request);
 453 }
 454
 455 void sipe_http_request_session(struct sipe_http_request *request,
 456                                struct sipe_http_session *session)
 457 {
 458         request->session = session;
 459 }
 460
 461 void sipe_http_request_allow_redirect(struct sipe_http_request *request)
 462 {
 463         request->flags |= SIPE_HTTP_REQUEST_FLAG_REDIRECT;
 464 }
 465
 466 void sipe_http_request_authentication(struct sipe_http_request *request,
 467                                       const gchar *domain,
 468                                       const gchar *user,
 469                                       const gchar *password)
 470 {
 471         request->flags   |= SIPE_HTTP_REQUEST_FLAG_AUTHDATA;
 472         request->domain   = domain;
 473         request->user     = user;
 474         request->password = password;
 475 }
 476
 477 /*
 478   Local Variables:
 479   mode: c
 480   c-file-style: "bsd"
 481   indent-tabs-mode: t
 482   tab-width: 8
 483   End:
 484 */