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 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include <string.h>
  29
  30 #include <glib.h>
  31
  32 #include "sipe-http.h"
  33
  34 #define _SIPE_HTTP_PRIVATE_IF_REQUEST
  35 #include "sipe-http-request.h"
  36 #define _SIPE_HTTP_PRIVATE_IF_TRANSPORT
  37 #include "sipe-http-transport.h"
  38
  39 struct sipe_http_connection {
  40         struct sipe_http_connection_public public;
  41         GSList *pending_requests;
  42 };
  43
  44 struct sipe_http_request {
  45         struct sipe_http_connection *connection;
  46
  47         gchar *path;
  48         gchar *headers;
  49         gchar *body;         /* NULL for GET */
  50         gchar *content_type; /* NULL if body == NULL */
  51
  52         sipe_http_response_callback *cb;
  53         gpointer cb_data;
  54 };
  55
  56 struct sipe_http_connection_public *sipe_http_connection_new(struct sipe_core_private *sipe_private,
  57                                                              const gchar *host,
  58                                                              guint32 port)
  59 {
  60         struct sipe_http_connection *conn = g_new0(struct sipe_http_connection, 1);
  61
  62         conn->public.sipe_private = sipe_private;
  63         conn->public.host         = g_strdup(host);
  64         conn->public.port         = port;
  65
  66         return((struct sipe_http_connection_public *) conn);
  67 }
  68
  69 static void sipe_http_request_free(struct sipe_core_private *sipe_private,
  70                                    struct sipe_http_request *req)
  71 {
  72         if (req->cb)
  73                 /* Callback: aborted */
  74                 (*req->cb)(sipe_private, 0, NULL, req->cb_data);
  75         g_free(req->path);
  76         g_free(req->headers);
  77         g_free(req->body);
  78         g_free(req->content_type);
  79         g_free(req);
  80 }
  81
  82 static void sipe_http_request_send(struct sipe_http_connection *conn)
  83 {
  84         struct sipe_http_request *req = conn->pending_requests->data;
  85         gchar *header;
  86         gchar *content = NULL;
  87
  88         if (req->body)
  89                 content = g_strdup_printf("Content-Length: %" G_GSIZE_FORMAT "\r\n"
  90                                           "Content-Type: %s\r\n",
  91                                           strlen(req->body),
  92                                           req->content_type);
  93
  94         header = g_strdup_printf("%s /%s HTTP/1.1\r\n"
  95                                  "Host: %s\r\n"
  96                                  "User-Agent: Sipe/" PACKAGE_VERSION "\r\n"
  97                                  "%s%s",
  98                                  content ? "POST" : "GET",
  99                                  req->path,
 100                                  conn->public.host,
 101                                  req->headers ? req->headers : "",
 102                                  content ? content : "");
 103         g_free(content);
 104
 105         sipe_http_transport_send((struct sipe_http_connection_public *) conn,
 106                                  header,
 107                                  req->body);
 108         g_free(header);
 109 }
 110
 111 gboolean sipe_http_request_pending(struct sipe_http_connection_public *conn_public)
 112 {
 113         return(((struct sipe_http_connection *) conn_public)->pending_requests != NULL);
 114 }
 115
 116 void sipe_http_request_next(struct sipe_http_connection_public *conn_public)
 117 {
 118         sipe_http_request_send((struct sipe_http_connection *) conn_public);
 119 }
 120
 121 void sipe_http_request_response(struct sipe_http_connection_public *conn_public,
 122                                 guint status,
 123                                 const gchar *body)
 124 {
 125         struct sipe_core_private *sipe_private = conn_public->sipe_private;
 126         struct sipe_http_connection *conn = (struct sipe_http_connection *) conn_public;
 127         struct sipe_http_request *req = conn->pending_requests->data;
 128
 129         /* Callback: success */
 130         (*req->cb)(sipe_private, status, body, req->cb_data);
 131
 132         /* remove completed request */
 133         sipe_http_request_cancel(req);
 134 }
 135
 136 void sipe_http_request_shutdown(struct sipe_http_connection_public *conn_public)
 137 {
 138         struct sipe_http_connection *conn = (struct sipe_http_connection *) conn_public;
 139
 140         if (conn->pending_requests) {
 141                 GSList *entry = conn->pending_requests;
 142                 while (entry) {
 143                         sipe_http_request_free(conn_public->sipe_private,
 144                                                entry->data);
 145                         entry = entry->next;
 146                 }
 147                 g_slist_free(conn->pending_requests);
 148         }
 149
 150         g_free(conn->public.host);
 151         g_free(conn);
 152 }
 153
 154 struct sipe_http_request *sipe_http_request_new(struct sipe_core_private *sipe_private,
 155                                                 const gchar *host,
 156                                                 guint32 port,
 157                                                 const gchar *path,
 158                                                 const gchar *headers,
 159                                                 const gchar *body,
 160                                                 const gchar *content_type,
 161                                                 sipe_http_response_callback *callback,
 162                                                 gpointer callback_data)
 163 {
 164         struct sipe_http_request *req = g_new0(struct sipe_http_request, 1);
 165         struct sipe_http_connection *conn;
 166         gboolean initial;
 167
 168         req->path                 = g_strdup(path);
 169         if (headers)
 170                 req->headers      = g_strdup(headers);
 171         if (body) {
 172                 req->body         = g_strdup(body);
 173                 req->content_type = g_strdup(content_type);
 174         }
 175
 176         req->cb      = callback;
 177         req->cb_data = callback_data;
 178
 179         req->connection = conn = (struct sipe_http_connection *) sipe_http_transport_new(sipe_private,
 180                                                                                          host,
 181                                                                                          port);
 182         initial = conn->pending_requests == NULL;
 183
 184         conn->pending_requests = g_slist_append(conn->pending_requests, req);
 185
 186         /* pass first request on already opened connection through directly */
 187         if (initial && conn->public.connected)
 188                 sipe_http_request_send(conn);
 189
 190         return(req);
 191 }
 192
 193 struct sipe_http_session *sipe_http_session_start(void)
 194 {
 195         return(NULL);
 196 }
 197
 198 void sipe_http_session_close(struct sipe_http_session *session)
 199 {
 200         (void)session;
 201 }
 202
 203 void sipe_http_request_cancel(struct sipe_http_request *request)
 204 {
 205         struct sipe_http_connection *conn = request->connection;
 206         conn->pending_requests = g_slist_remove(conn->pending_requests,
 207                                                 request);
 208
 209         /* cancelled by requester, don't use callback */
 210         request->cb = NULL;
 211
 212         sipe_http_request_free(conn->public.sipe_private, request);
 213 }
 214
 215 void sipe_http_request_session(struct sipe_http_request *request,
 216                                const struct sipe_http_session *session)
 217 {
 218         (void)request;
 219         (void)session;
 220 }
 221
 222 /*
 223   Local Variables:
 224   mode: c
 225   c-file-style: "bsd"
 226   indent-tabs-mode: t
 227   tab-width: 8
 228   End:
 229 */