libbeagle/beagle/beagle-request.c

   1 /*
   2  * beagle-request.c
   3  *
   4  * Copyright (C) 2005 Novell, Inc.
   5  *
   6  */
   7
   8 /*
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25  * DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include <config.h>
  30 #endif
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <sys/types.h>
  35 #include <sys/socket.h>
  36 #include <sys/un.h>
  37
  38 #include "beagle-error-response.h"
  39 #include "beagle-marshal.h"
  40 #include "beagle-parser.h"
  41 #include "beagle-request.h"
  42 #include "beagle-private.h"
  43 #include "beagle-util.h"
  44
  45 typedef struct {
  46         char *path;
  47         GIOChannel *channel;
  48         guint io_watch;
  49         BeagleParserContext *ctx;
  50 #ifdef ENABLE_XML_DUMP
  51         GString *data;
  52 #endif
  53 } BeagleRequestPrivate;
  54
  55 #define BEAGLE_REQUEST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BEAGLE_TYPE_REQUEST, BeagleRequestPrivate))
  56
  57 enum {
  58         CLOSED,
  59         RESPONSE,
  60         ERROR,
  61         LAST_SIGNAL
  62 };
  63
  64 static GObjectClass *parent_class = NULL;
  65 static guint signals [LAST_SIGNAL] = { 0 };
  66
  67 G_DEFINE_TYPE (BeagleRequest, beagle_request, G_TYPE_OBJECT)
  68
  69 static void
  70 beagle_request_finalize (GObject *obj)
  71 {
  72         BeagleRequestPrivate *priv = BEAGLE_REQUEST_GET_PRIVATE (obj);
  73
  74         g_free (priv->path);
  75
  76         if (priv->io_watch != 0) {
  77                 g_source_remove (priv->io_watch);
  78                 priv->io_watch = 0;
  79         }
  80
  81         if (priv->channel) {
  82                 g_io_channel_unref (priv->channel);
  83                 priv->channel = NULL;
  84         }
  85
  86         if (G_OBJECT_CLASS (parent_class)->finalize)
  87                 G_OBJECT_CLASS (parent_class)->finalize (obj);
  88 }
  89
  90 static void
  91 beagle_request_class_init (BeagleRequestClass *klass)
  92 {
  93         GObjectClass *obj_class = G_OBJECT_CLASS (klass);
  94
  95         parent_class = g_type_class_peek_parent (klass);
  96
  97         obj_class->finalize = beagle_request_finalize;
  98
  99         signals [CLOSED] = g_signal_new ("closed",
 100                                          G_TYPE_FROM_CLASS (klass),
 101                                          G_SIGNAL_RUN_LAST,
 102                                          G_STRUCT_OFFSET (BeagleRequestClass, closed),
 103                                          NULL, NULL,
 104                                          beagle_marshal_VOID__VOID,
 105                                          G_TYPE_NONE, 0);
 106         signals [RESPONSE] = g_signal_new ("response",
 107                                            G_TYPE_FROM_CLASS (klass),
 108                                            G_SIGNAL_RUN_LAST,
 109                                            G_STRUCT_OFFSET (BeagleRequestClass, response),
 110                                            NULL, NULL,
 111                                            g_cclosure_marshal_VOID__OBJECT,
 112                                            G_TYPE_NONE, 1,
 113                                            BEAGLE_TYPE_RESPONSE);
 114         signals [ERROR] = g_signal_new ("error",
 115                                         G_TYPE_FROM_CLASS (klass),
 116                                         G_SIGNAL_RUN_LAST,
 117                                         G_STRUCT_OFFSET (BeagleRequestClass, error),
 118                                         NULL, NULL,
 119                                         g_cclosure_marshal_VOID__POINTER,
 120                                         G_TYPE_NONE, 1,
 121                                         G_TYPE_POINTER);
 122
 123         g_type_class_add_private (klass, sizeof (BeagleRequestPrivate));
 124
 125         klass->response_types = g_hash_table_new_full (g_str_hash,
 126                                                        g_str_equal,
 127                                                        g_free,
 128                                                        NULL);
 129
 130         g_hash_table_insert (klass->response_types,
 131                              g_strdup ("ErrorResponse"),
 132                              (gpointer) BEAGLE_TYPE_ERROR_RESPONSE);
 133 }
 134
 135 static void
 136 beagle_request_init (BeagleRequest *request)
 137 {
 138 }
 139
 140 void
 141 _beagle_request_class_set_response_types (BeagleRequestClass *klass,
 142                                           const char *beagle_type,
 143                                           GType gobject_type,
 144                                           ...)
 145 {
 146         va_list args;
 147         const char *arg;
 148
 149         g_hash_table_replace (klass->response_types,
 150                               g_strdup (beagle_type),
 151                               (gpointer) gobject_type);
 152
 153         va_start (args, gobject_type);
 154         arg = va_arg (args, const char *);
 155
 156         while (arg != NULL) {
 157                 GType gtype = va_arg (args, GType);
 158
 159                 g_hash_table_replace (klass->response_types,
 160                                       g_strdup (arg),
 161                                       (gpointer) gtype);
 162
 163                 arg = va_arg (args, const char *);
 164         }
 165
 166         va_end (args);
 167 }
 168
 169 static gboolean
 170 request_connect (BeagleRequest *request, const char *path, GError **err)
 171 {
 172         BeagleRequestPrivate *priv;
 173         int sockfd;
 174         struct sockaddr_un sun;
 175
 176         priv = BEAGLE_REQUEST_GET_PRIVATE (request);
 177
 178         sockfd = socket (AF_UNIX, SOCK_STREAM, 0);
 179         if (sockfd < 0) {
 180                 g_set_error (err, BEAGLE_ERROR, BEAGLE_ERROR,
 181                              "Unable to create connection");
 182                 return FALSE;
 183         }
 184
 185         bzero (&sun, sizeof (sun));
 186         sun.sun_family = AF_UNIX;
 187         snprintf (sun.sun_path, sizeof (sun.sun_path), path);
 188
 189         if (connect (sockfd, (struct sockaddr *) &sun, sizeof (sun)) < 0) {
 190                 g_set_error (err, BEAGLE_ERROR, BEAGLE_ERROR,
 191                              "Unable to connect to Beagle daemon");
 192                 return FALSE;
 193         }
 194
 195         g_free (priv->path);
 196         priv->path = g_strdup (path);
 197
 198         priv->channel = g_io_channel_unix_new (sockfd);
 199
 200         g_io_channel_set_encoding (priv->channel, NULL, NULL);
 201         g_io_channel_set_buffered (priv->channel, FALSE);
 202         g_io_channel_set_close_on_unref (priv->channel, TRUE);
 203
 204         return TRUE;
 205 }
 206
 207 static void
 208 request_close (BeagleRequest *request)
 209 {
 210         BeagleRequestPrivate *priv;
 211
 212         priv = BEAGLE_REQUEST_GET_PRIVATE (request);
 213
 214         g_return_if_fail (priv->channel != NULL);
 215
 216         g_free (priv->path);
 217         priv->path = NULL;
 218
 219         g_io_channel_unref (priv->channel);
 220         priv->channel = NULL;
 221
 222         g_source_remove (priv->io_watch);
 223         priv->io_watch = 0;
 224
 225         g_signal_emit (request, signals [CLOSED], 0);
 226 }
 227
 228 static gboolean
 229 request_send (BeagleRequest *request, const char *socket_path, GError **err)
 230 {
 231         BeagleRequestPrivate *priv;
 232         GString *buffer;
 233         gsize bytes_written, total_written;
 234         char eom_marker = 0xff;
 235         GIOStatus status;
 236
 237         if (!request_connect (request, socket_path, err))
 238                 return FALSE;
 239
 240         priv = BEAGLE_REQUEST_GET_PRIVATE (request);
 241
 242         buffer = BEAGLE_REQUEST_GET_CLASS (request)->to_xml (request, err);
 243         if (buffer == NULL)
 244                 return FALSE;
 245
 246 #ifdef ENABLE_XML_DUMP
 247         printf ("Sending request:\n");
 248         printf ("%*s\n\n", buffer->len, buffer->str);
 249 #endif
 250
 251         /* Send the data over the wire */
 252         total_written = 0;
 253         do {
 254                 status = g_io_channel_write_chars (priv->channel,
 255                                                    buffer->str + total_written,
 256                                                    buffer->len - total_written,
 257                                                    &bytes_written,
 258                                                    err);
 259                 total_written += bytes_written;
 260         } while ((status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_AGAIN)
 261                  && total_written < buffer->len);
 262
 263         if (status == G_IO_STATUS_ERROR)
 264                 return FALSE;
 265
 266         /* And send the end-of-message marker */
 267         do {
 268                 status = g_io_channel_write_chars (priv->channel,
 269                                                    &eom_marker, 1,
 270                                                    &bytes_written,
 271                                                    err);
 272         } while ((status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_AGAIN)
 273                  && total_written == 0);
 274
 275         if (status == G_IO_STATUS_ERROR)
 276                 return FALSE;
 277
 278         return TRUE;
 279 }
 280
 281 static gboolean
 282 request_io_cb (GIOChannel *channel, GIOCondition condition, gpointer user_data)
 283 {
 284         BeagleRequestPrivate *priv = BEAGLE_REQUEST_GET_PRIVATE (user_data);
 285         gsize bytes_read;
 286         char buf[4096];
 287         GIOStatus status;
 288         char *marker;
 289         int start, to_parse;
 290         BeagleResponse *response;
 291
 292         if (condition & G_IO_IN) {
 293                 do {
 294                         GError *error = NULL;
 295
 296                         status = g_io_channel_read_chars (priv->channel,
 297                                                           buf, 4096,
 298                                                           &bytes_read,
 299                                                           &error);
 300
 301                         if (status == G_IO_STATUS_ERROR) {
 302                                 g_signal_emit (user_data, signals[ERROR], 0, error);
 303                                 g_error_free (error);
 304                                 error = NULL;
 305                         }
 306
 307                         if (bytes_read > 0) {
 308                                 start = 0;
 309
 310 #ifdef ENABLE_XML_DUMP
 311                                 if (priv->data == NULL)
 312                                         priv->data = g_string_new (NULL);
 313 #endif
 314
 315                                 while (start < bytes_read) {
 316                                         marker = memchr (buf + start, 0xff, bytes_read - start);
 317
 318                                         if (!priv->ctx) {
 319                                                 priv->ctx = _beagle_parser_context_new ();
 320                                         }
 321
 322                                         if (marker != NULL) {
 323                                                 to_parse = (marker - buf) - start;
 324
 325                                                 if (to_parse > 0) {
 326 #ifdef ENABLE_XML_DUMP
 327                                                         priv->data = g_string_append_len (priv->data, buf + start, to_parse);
 328 #endif
 329                                                         _beagle_parser_context_parse_chunk (priv->ctx, buf + start, to_parse);
 330                                                 }
 331
 332 #ifdef ENABLE_XML_DUMP
 333                                                 printf ("Received async response:\n");
 334                                                 printf ("%s\n\n", priv->data->str);
 335                                                 g_string_free (priv->data, TRUE);
 336                                                 priv->data = NULL;
 337 #endif
 338
 339                                                 /* Finish the context */
 340                                                 response = _beagle_parser_context_finished (priv->ctx);
 341                                                 g_assert (response != NULL);
 342
 343                                                 if (BEAGLE_IS_ERROR_RESPONSE (response)) {
 344                                                         _beagle_error_response_to_g_error (BEAGLE_ERROR_RESPONSE (response), &error);
 345                                                         g_signal_emit (BEAGLE_REQUEST (user_data),
 346                                                                        signals[ERROR], 0, error);
 347                                                         g_error_free (error);
 348                                                         error = NULL;
 349                                                 } else {
 350                                                         g_signal_emit (BEAGLE_REQUEST (user_data),
 351                                                                        signals[RESPONSE], 0, response);
 352                                                 }
 353                                                 g_object_unref (response);
 354
 355                                                 /* Move past the 0xff marker */
 356                                                 start += to_parse + 1;
 357
 358                                                 priv->ctx = NULL;
 359                                         }
 360                                         else {
 361 #ifdef ENABLE_XML_DUMP
 362                                                 priv->data = g_string_append_len (priv->data, buf + start, bytes_read - start);
 363 #endif
 364                                                 _beagle_parser_context_parse_chunk (priv->ctx, buf + start, bytes_read - start);
 365                                                 break;
 366                                         }
 367                                 }
 368                         }
 369                 } while (bytes_read == 4096 || status == G_IO_STATUS_AGAIN);
 370         }
 371
 372         if (condition & G_IO_HUP ||
 373             condition & G_IO_ERR) {
 374                 request_close (BEAGLE_REQUEST (user_data));
 375         }
 376
 377         return TRUE;
 378 }
 379
 380 gboolean
 381 _beagle_request_send_async (BeagleRequest  *request,
 382                             const char     *socket_path,
 383                             GError        **err)
 384 {
 385         BeagleRequestPrivate *priv = BEAGLE_REQUEST_GET_PRIVATE (request);
 386
 387         if (!request_send (request, socket_path, err))
 388                 return FALSE;
 389
 390         priv->io_watch = g_io_add_watch (priv->channel,
 391                                          G_IO_IN | G_IO_HUP | G_IO_ERR,
 392                                          request_io_cb,
 393                                          request);
 394
 395         return TRUE;
 396 }
 397
 398 BeagleResponse *
 399 _beagle_request_send (BeagleRequest *request, const char *socket_path, GError **err)
 400 {
 401         BeagleRequestPrivate *priv;
 402         BeagleParserContext *ctx;
 403         char buf [4096];
 404         gsize bytes_read;
 405         GIOStatus status;
 406         char *marker = NULL;
 407         BeagleResponse *response;
 408
 409         if (!request_send (request, socket_path, err))
 410                 return FALSE;
 411
 412         priv = BEAGLE_REQUEST_GET_PRIVATE (request);
 413
 414         ctx = _beagle_parser_context_new ();
 415
 416 #ifdef ENABLE_XML_DUMP
 417         priv->data = g_string_new (NULL);
 418 #endif
 419
 420         do {
 421                 gsize to_parse;
 422
 423                 status = g_io_channel_read_chars (priv->channel,
 424                                                   buf, 4096,
 425                                                   &bytes_read,
 426                                                   err);
 427
 428                 if (bytes_read > 0) {
 429                         marker = memchr (buf, 0xff, bytes_read);
 430
 431                         if (marker != NULL)
 432                                 to_parse = marker - buf;
 433                         else
 434                                 to_parse = bytes_read;
 435
 436 #ifdef ENABLE_XML_DUMP
 437                         priv->data = g_string_append_len (priv->data, buf, to_parse);
 438 #endif
 439                         _beagle_parser_context_parse_chunk (ctx, buf, to_parse);
 440                 }
 441         } while ((status == G_IO_STATUS_NORMAL || G_IO_STATUS_AGAIN) &&
 442                  marker == NULL);
 443
 444 #ifdef ENABLE_XML_DUMP
 445         printf ("Received sync response:\n");
 446         printf ("%s\n\n", priv->data->str);
 447         g_string_free (priv->data, TRUE);
 448         priv->data = NULL;
 449 #endif
 450
 451         response = _beagle_parser_context_finished (ctx);
 452
 453         g_io_channel_unref (priv->channel);
 454         priv->channel = NULL;
 455
 456         if (BEAGLE_IS_ERROR_RESPONSE (response)) {
 457                 _beagle_error_response_to_g_error (BEAGLE_ERROR_RESPONSE (response), err);
 458                 g_object_unref (response);
 459                 return NULL;
 460         }
 461
 462         return response;
 463 }
 464
 465 void
 466 _beagle_request_append_standard_header (GString *data, const char *xsi_type)
 467 {
 468         const char header[] =
 469                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
 470                 "<RequestWrapper xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
 471                 "<Message xsi:type=\"";
 472
 473         g_string_append_len (data, header, sizeof (header) - 1);
 474         g_string_append (data, xsi_type);
 475         g_string_append_len (data, "\">", 2);
 476 }
 477
 478 void
 479 _beagle_request_append_standard_footer (GString *data)
 480 {
 481         const char footer[] = "</Message></RequestWrapper>";
 482
 483         g_string_append_len (data, footer, sizeof (footer) - 1);
 484 }