Pileus Git - ~andy/gtk/blob - gdk/broadway/gdkdisplay-broadway.c

   1 /* GDK - The GIMP Drawing Kit
   2  * gdkdisplay-broadway.c
   3  *
   4  * Copyright 2001 Sun Microsystems Inc.
   5  * Copyright (C) 2004 Nokia Corporation
   6  *
   7  * Erwann Chenede <erwann.chenede@sun.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library 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 GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include "config.h"
  26
  27 #include "gdkdisplay-broadway.h"
  28
  29 #include "gdkdisplay.h"
  30 #include "gdkeventsource.h"
  31 #include "gdkscreen.h"
  32 #include "gdkscreen-broadway.h"
  33 #include "gdkinternals.h"
  34 #include "gdkdeviceprivate.h"
  35 #include "gdkdevicemanager-broadway.h"
  36
  37 #include <glib.h>
  38 #include <glib/gprintf.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <errno.h>
  42 #include <unistd.h>
  43 #include <sys/types.h>
  44 #include <sys/socket.h>
  45 #include <netinet/in.h>
  46 #include <netinet/tcp.h>
  47
  48 static void   gdk_broadway_display_dispose            (GObject            *object);
  49 static void   gdk_broadway_display_finalize           (GObject            *object);
  50
  51 #if 0
  52 #define DEBUG_WEBSOCKETS 1
  53 #endif
  54
  55 G_DEFINE_TYPE (GdkBroadwayDisplay, gdk_broadway_display, GDK_TYPE_DISPLAY)
  56
  57 static void
  58 gdk_broadway_display_init (GdkBroadwayDisplay *display)
  59 {
  60   _gdk_broadway_display_manager_add_display (gdk_display_manager_get (),
  61                                              GDK_DISPLAY_OBJECT (display));
  62   display->id_ht = g_hash_table_new (NULL, NULL);
  63 }
  64
  65 static void
  66 gdk_event_init (GdkDisplay *display)
  67 {
  68   GdkBroadwayDisplay *broadway_display;
  69
  70   broadway_display = GDK_BROADWAY_DISPLAY (display);
  71   broadway_display->event_source = _gdk_broadway_event_source_new (display);
  72   broadway_display->saved_serial = 1;
  73   broadway_display->last_seen_time = 1;
  74 }
  75
  76 static void
  77 gdk_broadway_display_init_input (GdkDisplay *display)
  78 {
  79   GdkBroadwayDisplay *broadway_display;
  80   GdkDeviceManager *device_manager;
  81   GdkDevice *device;
  82   GList *list, *l;
  83
  84   broadway_display = GDK_BROADWAY_DISPLAY (display);
  85   device_manager = gdk_display_get_device_manager (display);
  86
  87   /* For backwards compatibility, just add
  88    * floating devices that are not keyboards.
  89    */
  90   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
  91
  92   for (l = list; l; l = l->next)
  93     {
  94       device = l->data;
  95
  96       if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
  97         continue;
  98
  99       broadway_display->input_devices = g_list_prepend (broadway_display->input_devices,
 100                                                    g_object_ref (l->data));
 101     }
 102
 103   g_list_free (list);
 104
 105   /* Now set "core" pointer to the first
 106    * master device that is a pointer.
 107    */
 108   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
 109
 110   for (l = list; l; l = l->next)
 111     {
 112       device = list->data;
 113
 114       if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
 115         continue;
 116
 117       display->core_pointer = device;
 118       break;
 119     }
 120
 121   /* Add the core pointer to the devices list */
 122   broadway_display->input_devices = g_list_prepend (broadway_display->input_devices,
 123                                                g_object_ref (display->core_pointer));
 124
 125   g_list_free (list);
 126 }
 127
 128 typedef struct HttpRequest {
 129   GdkDisplay *display;
 130   GSocketConnection *connection;
 131   GDataInputStream *data;
 132   GString *request;
 133 }  HttpRequest;
 134
 135 static void start_output (HttpRequest *request, gboolean proto_v7_plus);
 136
 137 static void
 138 http_request_free (HttpRequest *request)
 139 {
 140   g_object_unref (request->connection);
 141   g_object_unref (request->data);
 142   g_string_free (request->request, TRUE);
 143   g_free (request);
 144 }
 145
 146 struct BroadwayInput {
 147   GdkDisplay *display;
 148   GSocketConnection *connection;
 149   GByteArray *buffer;
 150   GSource *source;
 151   gboolean seen_time;
 152   gint64 time_base;
 153   gboolean proto_v7_plus;
 154 };
 155
 156 static void
 157 broadway_input_free (BroadwayInput *input)
 158 {
 159   g_object_unref (input->connection);
 160   g_byte_array_free (input->buffer, FALSE);
 161   g_source_destroy (input->source);
 162   g_free (input);
 163 }
 164
 165 static void
 166 process_input_messages (GdkBroadwayDisplay *broadway_display)
 167 {
 168   BroadwayInputMsg *message;
 169
 170   while (broadway_display->input_messages)
 171     {
 172       message = broadway_display->input_messages->data;
 173       broadway_display->input_messages =
 174         g_list_delete_link (broadway_display->input_messages,
 175                             broadway_display->input_messages);
 176
 177       _gdk_broadway_events_got_input (GDK_DISPLAY (broadway_display), message);
 178       g_free (message);
 179     }
 180 }
 181
 182 static char *
 183 parse_pointer_data (char *p, BroadwayInputPointerMsg *data)
 184 {
 185   data->mouse_window_id = strtol (p, &p, 10);
 186   p++; /* Skip , */
 187   data->event_window_id = strtol (p, &p, 10);
 188   p++; /* Skip , */
 189   data->root_x = strtol (p, &p, 10);
 190   p++; /* Skip , */
 191   data->root_y = strtol (p, &p, 10);
 192   p++; /* Skip , */
 193   data->win_x = strtol (p, &p, 10);
 194   p++; /* Skip , */
 195   data->win_y = strtol (p, &p, 10);
 196   p++; /* Skip , */
 197   data->state = strtol (p, &p, 10);
 198
 199   return p;
 200 }
 201
 202 static void
 203 update_future_pointer_info (GdkBroadwayDisplay *broadway_display, BroadwayInputPointerMsg *data)
 204 {
 205   broadway_display->future_root_x = data->root_x;
 206   broadway_display->future_root_y = data->root_y;
 207   broadway_display->future_state = data->state;
 208   broadway_display->future_mouse_in_toplevel = data->mouse_window_id;
 209 }
 210
 211 static void
 212 parse_input_message (BroadwayInput *input, const char *message)
 213 {
 214   GdkBroadwayDisplay *broadway_display;
 215   BroadwayInputMsg msg;
 216   char *p;
 217   gint64 time_;
 218
 219   broadway_display = GDK_BROADWAY_DISPLAY (input->display);
 220
 221   p = (char *)message;
 222   msg.base.type = *p++;
 223   msg.base.serial = (guint32)strtol (p, &p, 10);
 224   p++; /* Skip , */
 225   time_ = strtol(p, &p, 10);
 226   p++; /* Skip , */
 227
 228   if (time_ == 0) {
 229     time_ = broadway_display->last_seen_time;
 230   } else {
 231     if (!input->seen_time) {
 232       input->seen_time = TRUE;
 233       /* Calculate time base so that any following times are normalized to start
 234          5 seconds after last_seen_time, to avoid issues that could appear when
 235          a long hiatus due to a reconnect seems to be instant */
 236       input->time_base = time_ - (broadway_display->last_seen_time + 5000);
 237     }
 238     time_ = time_ - input->time_base;
 239   }
 240
 241   broadway_display->last_seen_time = time_;
 242
 243   msg.base.time = time_;
 244
 245   switch (msg.base.type) {
 246   case 'e': /* Enter */
 247   case 'l': /* Leave */
 248     p = parse_pointer_data (p, &msg.pointer);
 249     update_future_pointer_info (broadway_display, &msg.pointer);
 250     p++; /* Skip , */
 251     msg.crossing.mode = strtol(p, &p, 10);
 252     break;
 253
 254   case 'm': /* Mouse move */
 255     p = parse_pointer_data (p, &msg.pointer);
 256     update_future_pointer_info (broadway_display, &msg.pointer);
 257     break;
 258
 259   case 'b':
 260   case 'B':
 261     p = parse_pointer_data (p, &msg.pointer);
 262     update_future_pointer_info (broadway_display, &msg.pointer);
 263     p++; /* Skip , */
 264     msg.button.button = strtol(p, &p, 10);
 265     break;
 266
 267   case 's':
 268     p = parse_pointer_data (p, &msg.pointer);
 269     update_future_pointer_info (broadway_display, &msg.pointer);
 270     p++; /* Skip , */
 271     msg.scroll.dir = strtol(p, &p, 10);
 272     break;
 273
 274   case 'k':
 275   case 'K':
 276     msg.key.key = strtol(p, &p, 10);
 277     p++; /* Skip , */
 278     msg.key.state = strtol(p, &p, 10);
 279     break;
 280
 281   case 'g':
 282   case 'u':
 283     msg.grab_reply.res = strtol(p, &p, 10);
 284     break;
 285
 286   case 'w':
 287     msg.configure_notify.id = strtol(p, &p, 10);
 288     p++; /* Skip , */
 289     msg.configure_notify.x = strtol (p, &p, 10);
 290     p++; /* Skip , */
 291     msg.configure_notify.y = strtol (p, &p, 10);
 292     p++; /* Skip , */
 293     msg.configure_notify.width = strtol (p, &p, 10);
 294     p++; /* Skip , */
 295     msg.configure_notify.height = strtol (p, &p, 10);
 296     break;
 297
 298   case 'W':
 299     msg.delete_notify.id = strtol(p, &p, 10);
 300     break;
 301
 302   case 'd':
 303     msg.screen_resize_notify.width = strtol (p, &p, 10);
 304     p++; /* Skip , */
 305     msg.screen_resize_notify.height = strtol (p, &p, 10);
 306     break;
 307
 308   default:
 309     g_printerr ("Unknown input command %s\n", message);
 310     break;
 311   }
 312
 313   broadway_display->input_messages = g_list_append (broadway_display->input_messages, g_memdup (&msg, sizeof (msg)));
 314
 315 }
 316
 317 static inline void
 318 hex_dump (guchar *data, gsize len)
 319 {
 320 #ifdef DEBUG_WEBSOCKETS
 321   gsize i, j;
 322   for (j = 0; j < len + 15; j += 16)
 323     {
 324       fprintf (stderr, "0x%.4x  ", j);
 325       for (i = 0; i < 16; i++)
 326         {
 327             if ((j + i) < len)
 328               fprintf (stderr, "%.2x ", data[j+i]);
 329             else
 330               fprintf (stderr, "  ");
 331             if (i == 8)
 332               fprintf (stderr, " ");
 333         }
 334       fprintf (stderr, " | ");
 335
 336       for (i = 0; i < 16; i++)
 337         if ((j + i) < len && g_ascii_isalnum(data[j+i]))
 338           fprintf (stderr, "%c", data[j+i]);
 339         else
 340           fprintf (stderr, ".");
 341       fprintf (stderr, "\n");
 342     }
 343 #endif
 344 }
 345
 346 static void
 347 parse_input (BroadwayInput *input)
 348 {
 349   GdkBroadwayDisplay *broadway_display;
 350
 351   broadway_display = GDK_BROADWAY_DISPLAY (input->display);
 352
 353   if (!input->buffer->len)
 354     return;
 355
 356   if (input->proto_v7_plus)
 357     {
 358       hex_dump (input->buffer->data, input->buffer->len);
 359
 360       while (input->buffer->len > 2)
 361         {
 362           gsize len, payload_len;
 363           BroadwayWSOpCode code;
 364           gboolean is_mask, fin;
 365           guchar *buf, *data, *mask;
 366
 367           buf = input->buffer->data;
 368           len = input->buffer->len;
 369
 370 #ifdef DEBUG_WEBSOCKETS
 371           g_print ("Parse input first byte 0x%2x 0x%2x\n", buf[0], buf[1]);
 372 #endif
 373
 374           fin = buf[0] & 0x80;
 375           code = buf[0] & 0x0f;
 376           payload_len = buf[1] & 0x7f;
 377           is_mask = buf[1] & 0x80;
 378           data = buf + 2;
 379
 380           if (payload_len > 125)
 381             {
 382               if (len < 4)
 383                 return;
 384               payload_len = GUINT16_FROM_BE( *(guint16 *) data );
 385               data += 2;
 386             }
 387           else if (payload_len > 126)
 388             {
 389               if (len < 10)
 390                 return;
 391               payload_len = GUINT64_FROM_BE( *(guint64 *) data );
 392               data += 8;
 393             }
 394
 395           mask = NULL;
 396           if (is_mask)
 397             {
 398               if (data - buf + 4 > len)
 399                 return;
 400               mask = data;
 401               data += 4;
 402             }
 403
 404           if (data - buf + payload_len > len)
 405             return; /* wait to accumulate more */
 406
 407           if (is_mask)
 408             {
 409               gsize i;
 410               for (i = 0; i < payload_len; i++)
 411                 data[i] ^= mask[i%4];
 412             }
 413
 414           switch (code) {
 415           case BROADWAY_WS_CNX_CLOSE:
 416             break; /* hang around anyway */
 417           case BROADWAY_WS_TEXT:
 418             if (!fin)
 419               {
 420 #ifdef DEBUG_WEBSOCKETS
 421                 g_warning ("can't yet accept fragmented input");
 422 #endif
 423               }
 424             else
 425               {
 426                 char *terminated = g_strndup((char *)data, payload_len);
 427                 parse_input_message (input, terminated);
 428                 g_free (terminated);
 429               }
 430             break;
 431           case BROADWAY_WS_CNX_PING:
 432             broadway_output_pong (broadway_display->output);
 433             break;
 434           case BROADWAY_WS_CNX_PONG:
 435             break; /* we never send pings, but tolerate pongs */
 436           case BROADWAY_WS_BINARY:
 437           case BROADWAY_WS_CONTINUATION:
 438           default:
 439             {
 440               g_warning ("fragmented or unknown input code 0x%2x with fin set", code);
 441               break;
 442             }
 443           }
 444
 445           g_byte_array_remove_range (input->buffer, 0, data - buf + payload_len);
 446         }
 447     }
 448   else /* old style protocol */
 449     {
 450       char *buf, *ptr;
 451       gsize len;
 452
 453       buf = (char *)input->buffer->data;
 454       len = input->buffer->len;
 455
 456       if (buf[0] != 0)
 457         {
 458           broadway_display->input = NULL;
 459           broadway_input_free (input);
 460           return;
 461         }
 462
 463       while ((ptr = memchr (buf, 0xff, len)) != NULL)
 464         {
 465           *ptr = 0;
 466           ptr++;
 467
 468           parse_input_message (input, buf + 1);
 469
 470           len -= ptr - buf;
 471           buf = ptr;
 472
 473           if (len > 0 && buf[0] != 0)
 474             {
 475               broadway_display->input = NULL;
 476               broadway_input_free (input);
 477               break;
 478             }
 479         }
 480       g_byte_array_remove_range (input->buffer, 0, buf - (char *)input->buffer->data);
 481     }
 482 }
 483
 484
 485 static gboolean
 486 process_input_idle_cb (GdkBroadwayDisplay *display)
 487 {
 488   display->process_input_idle = 0;
 489   process_input_messages (display);
 490   return G_SOURCE_REMOVE;
 491 }
 492
 493 static void
 494 queue_process_input_at_idle (GdkBroadwayDisplay *broadway_display)
 495 {
 496   if (broadway_display->process_input_idle == 0)
 497     broadway_display->process_input_idle =
 498       g_idle_add_full (GDK_PRIORITY_EVENTS, (GSourceFunc)process_input_idle_cb, broadway_display, NULL);
 499 }
 500
 501 static void
 502 _gdk_broadway_display_read_all_input_nonblocking (GdkDisplay *display)
 503 {
 504   GdkBroadwayDisplay *broadway_display;
 505   GInputStream *in;
 506   gssize res;
 507   guint8 buffer[1024];
 508   GError *error;
 509   BroadwayInput *input;
 510
 511   broadway_display = GDK_BROADWAY_DISPLAY (display);
 512   if (broadway_display->input == NULL)
 513     return;
 514
 515   input = broadway_display->input;
 516
 517   in = g_io_stream_get_input_stream (G_IO_STREAM (input->connection));
 518
 519   error = NULL;
 520   res = g_pollable_input_stream_read_nonblocking (G_POLLABLE_INPUT_STREAM (in),
 521                                                   buffer, sizeof (buffer), NULL, &error);
 522
 523   if (res <= 0)
 524     {
 525       if (res < 0 &&
 526           g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
 527         {
 528           g_error_free (error);
 529           return;
 530         }
 531
 532       broadway_display->input = NULL;
 533       broadway_input_free (input);
 534       if (res < 0)
 535         {
 536           g_print ("input error %s\n", error->message);
 537           g_error_free (error);
 538         }
 539       return;
 540     }
 541
 542   g_byte_array_append (input->buffer, buffer, res);
 543
 544   parse_input (input);
 545 }
 546
 547 void
 548 _gdk_broadway_display_consume_all_input (GdkDisplay *display)
 549 {
 550   GdkBroadwayDisplay *broadway_display;
 551
 552   broadway_display = GDK_BROADWAY_DISPLAY (display);
 553   _gdk_broadway_display_read_all_input_nonblocking (display);
 554
 555   /* Since we're parsing input but not processing the resulting messages
 556      we might not get a readable callback on the stream, so queue an idle to
 557      process the messages */
 558   queue_process_input_at_idle (broadway_display);
 559 }
 560
 561
 562 static gboolean
 563 input_data_cb (GObject  *stream,
 564                BroadwayInput *input)
 565 {
 566   GdkBroadwayDisplay *broadway_display;
 567
 568   broadway_display = GDK_BROADWAY_DISPLAY (input->display);
 569   _gdk_broadway_display_read_all_input_nonblocking (input->display);
 570
 571   process_input_messages (broadway_display);
 572
 573   return TRUE;
 574 }
 575
 576 /* Note: This may be called while handling a message (i.e. sorta recursively) */
 577 BroadwayInputMsg *
 578 _gdk_broadway_display_block_for_input (GdkDisplay *display, char op,
 579                                        guint32 serial, gboolean remove_message)
 580 {
 581   GdkBroadwayDisplay *broadway_display;
 582   BroadwayInputMsg *message;
 583   gssize res;
 584   guint8 buffer[1024];
 585   BroadwayInput *input;
 586   GInputStream *in;
 587   GList *l;
 588
 589   gdk_display_flush (display);
 590
 591   broadway_display = GDK_BROADWAY_DISPLAY (display);
 592   if (broadway_display->input == NULL)
 593     return NULL;
 594
 595   input = broadway_display->input;
 596
 597   while (TRUE) {
 598     /* Check for existing reply in queue */
 599
 600     for (l = broadway_display->input_messages; l != NULL; l = l->next)
 601       {
 602         message = l->data;
 603
 604         if (message->base.type == op)
 605           {
 606             if (message->base.serial == serial)
 607               {
 608                 if (remove_message)
 609                   broadway_display->input_messages =
 610                     g_list_delete_link (broadway_display->input_messages, l);
 611                 return message;
 612               }
 613           }
 614       }
 615
 616     /* Not found, read more, blocking */
 617
 618     in = g_io_stream_get_input_stream (G_IO_STREAM (input->connection));
 619     res = g_input_stream_read (in, buffer, sizeof (buffer), NULL, NULL);
 620     if (res <= 0)
 621       return NULL;
 622     g_byte_array_append (input->buffer, buffer, res);
 623
 624     parse_input (input);
 625
 626     /* Since we're parsing input but not processing the resulting messages
 627        we might not get a readable callback on the stream, so queue an idle to
 628        process the messages */
 629     queue_process_input_at_idle (broadway_display);
 630   }
 631 }
 632
 633 static char *
 634 parse_line (char *line, char *key)
 635 {
 636   char *p;
 637
 638   if (!g_str_has_prefix (line, key))
 639     return NULL;
 640   p = line + strlen (key);
 641   if (*p != ':')
 642     return NULL;
 643   p++;
 644   /* Skip optional initial space */
 645   if (*p == ' ')
 646     p++;
 647   return p;
 648 }
 649 static void
 650 send_error (HttpRequest *request,
 651             int error_code,
 652             const char *reason)
 653 {
 654   char *res;
 655
 656   res = g_strdup_printf ("HTTP/1.0 %d %s\r\n\r\n"
 657                          "<html><head><title>%d %s</title></head>"
 658                          "<body>%s</body></html>",
 659                          error_code, reason,
 660                          error_code, reason,
 661                          reason);
 662   /* TODO: This should really be async */
 663   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 664                              res, strlen (res), NULL, NULL, NULL);
 665   g_free (res);
 666   http_request_free (request);
 667 }
 668
 669 /* magic from: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17 */
 670 #define SEC_WEB_SOCKET_KEY_MAGIC "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
 671
 672 /* 'x3JJHMbDL1EzLkh9GBhXDw==' generates 'HSmrc0sMlYUkAGmm5OPpG2HaGWk=' */
 673 static gchar *
 674 generate_handshake_response_wsietf_v7 (const gchar *key)
 675 {
 676   gsize digest_len = 20;
 677   guchar digest[digest_len];
 678   GChecksum *checksum;
 679
 680   checksum = g_checksum_new (G_CHECKSUM_SHA1);
 681   if (!checksum)
 682     return NULL;
 683
 684   g_checksum_update (checksum, (guchar *)key, -1);
 685   g_checksum_update (checksum, (guchar *)SEC_WEB_SOCKET_KEY_MAGIC, -1);
 686
 687   g_checksum_get_digest (checksum, digest, &digest_len);
 688   g_checksum_free (checksum);
 689
 690   g_assert (digest_len == 20);
 691
 692   return g_base64_encode (digest, digest_len);
 693 }
 694
 695 static void
 696 start_input (HttpRequest *request)
 697 {
 698   char **lines;
 699   char *p;
 700   int num_key1, num_key2;
 701   guint64 key1, key2;
 702   int num_space;
 703   int i;
 704   guint8 challenge[16];
 705   char *res;
 706   gsize len;
 707   GChecksum *checksum;
 708   char *origin, *host;
 709   GdkBroadwayDisplay *broadway_display;
 710   BroadwayInput *input;
 711   const void *data_buffer;
 712   gsize data_buffer_size;
 713   GInputStream *in;
 714   char *key_v7;
 715   gboolean proto_v7_plus;
 716
 717   broadway_display = GDK_BROADWAY_DISPLAY (request->display);
 718
 719   if (broadway_display->input != NULL)
 720     {
 721       send_error (request, 409, "Input already handled");
 722       return;
 723     }
 724
 725 #ifdef DEBUG_WEBSOCKETS
 726   g_print ("incoming request:\n%s\n", request->request->str);
 727 #endif
 728   lines = g_strsplit (request->request->str, "\n", 0);
 729
 730   num_key1 = 0;
 731   num_key2 = 0;
 732   key1 = 0;
 733   key2 = 0;
 734   key_v7 = NULL;
 735   origin = NULL;
 736   host = NULL;
 737   for (i = 0; lines[i] != NULL; i++)
 738     {
 739       if ((p = parse_line (lines[i], "Sec-WebSocket-Key1")))
 740         {
 741           num_space = 0;
 742           while (*p != 0)
 743             {
 744               if (g_ascii_isdigit (*p))
 745                 key1 = key1 * 10 + g_ascii_digit_value (*p);
 746               else if (*p == ' ')
 747                 num_space++;
 748
 749               p++;
 750             }
 751           key1 /= num_space;
 752           num_key1++;
 753         }
 754       else if ((p = parse_line (lines[i], "Sec-WebSocket-Key2")))
 755         {
 756           num_space = 0;
 757           while (*p != 0)
 758             {
 759               if (g_ascii_isdigit (*p))
 760                 key2 = key2 * 10 + g_ascii_digit_value (*p);
 761               else if (*p == ' ')
 762                 num_space++;
 763
 764               p++;
 765             }
 766           key2 /= num_space;
 767           num_key2++;
 768         }
 769       else if ((p = parse_line (lines[i], "Sec-WebSocket-Key")))
 770         {
 771           key_v7 = p;
 772         }
 773       else if ((p = parse_line (lines[i], "Origin")))
 774         {
 775           origin = p;
 776         }
 777       else if ((p = parse_line (lines[i], "Host")))
 778         {
 779           host = p;
 780         }
 781       else if ((p = parse_line (lines[i], "Sec-WebSocket-Origin")))
 782         {
 783           origin = p;
 784         }
 785     }
 786
 787   if (origin == NULL || host == NULL)
 788     {
 789       g_strfreev (lines);
 790       send_error (request, 400, "Bad websocket request");
 791       return;
 792     }
 793
 794   if (key_v7 != NULL)
 795     {
 796       char* accept = generate_handshake_response_wsietf_v7 (key_v7);
 797       res = g_strdup_printf ("HTTP/1.1 101 Switching Protocols\r\n"
 798                              "Upgrade: websocket\r\n"
 799                              "Connection: Upgrade\r\n"
 800                              "Sec-WebSocket-Accept: %s\r\n"
 801                              "Sec-WebSocket-Origin: %s\r\n"
 802                              "Sec-WebSocket-Location: ws://%s/socket\r\n"
 803                              "Sec-WebSocket-Protocol: broadway\r\n"
 804                              "\r\n", accept, origin, host);
 805       g_free (accept);
 806
 807 #ifdef DEBUG_WEBSOCKETS
 808       g_print ("v7 proto response:\n%s", res);
 809 #endif
 810
 811       g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 812                                  res, strlen (res), NULL, NULL, NULL);
 813       g_free (res);
 814       proto_v7_plus = TRUE;
 815     }
 816   else
 817     {
 818       if (num_key1 != 1 || num_key2 != 1)
 819         {
 820           g_strfreev (lines);
 821           send_error (request, 400, "Bad websocket request");
 822           return;
 823         }
 824
 825       challenge[0] = (key1 >> 24) & 0xff;
 826       challenge[1] = (key1 >> 16) & 0xff;
 827       challenge[2] = (key1 >>  8) & 0xff;
 828       challenge[3] = (key1 >>  0) & 0xff;
 829       challenge[4] = (key2 >> 24) & 0xff;
 830       challenge[5] = (key2 >> 16) & 0xff;
 831       challenge[6] = (key2 >>  8) & 0xff;
 832       challenge[7] = (key2 >>  0) & 0xff;
 833
 834       if (!g_input_stream_read_all (G_INPUT_STREAM (request->data), challenge+8, 8, NULL, NULL, NULL))
 835         {
 836           g_strfreev (lines);
 837           send_error (request, 400, "Bad websocket request");
 838           return;
 839         }
 840
 841       checksum = g_checksum_new (G_CHECKSUM_MD5);
 842       g_checksum_update (checksum, challenge, 16);
 843       len = 16;
 844       g_checksum_get_digest (checksum, challenge, &len);
 845       g_checksum_free (checksum);
 846
 847       res = g_strdup_printf ("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 848                              "Upgrade: WebSocket\r\n"
 849                              "Connection: Upgrade\r\n"
 850                              "Sec-WebSocket-Origin: %s\r\n"
 851                              "Sec-WebSocket-Location: ws://%s/socket\r\n"
 852                              "Sec-WebSocket-Protocol: broadway\r\n"
 853                              "\r\n",
 854                              origin, host);
 855
 856 #ifdef DEBUG_WEBSOCKETS
 857       g_print ("legacy response:\n%s", res);
 858 #endif
 859       g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 860                                  res, strlen (res), NULL, NULL, NULL);
 861       g_free (res);
 862       g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 863                                  challenge, 16, NULL, NULL, NULL);
 864       proto_v7_plus = FALSE;
 865     }
 866
 867   input = g_new0 (BroadwayInput, 1);
 868
 869   input->display = request->display;
 870   input->connection = g_object_ref (request->connection);
 871   input->proto_v7_plus = proto_v7_plus;
 872
 873   data_buffer = g_buffered_input_stream_peek_buffer (G_BUFFERED_INPUT_STREAM (request->data), &data_buffer_size);
 874   input->buffer = g_byte_array_sized_new (data_buffer_size);
 875   g_byte_array_append (input->buffer, data_buffer, data_buffer_size);
 876
 877   broadway_display->input = input;
 878
 879   start_output (request, proto_v7_plus);
 880
 881   /* This will free and close the data input stream, but we got all the buffered content already */
 882   http_request_free (request);
 883
 884   in = g_io_stream_get_input_stream (G_IO_STREAM (input->connection));
 885   input->source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (in), NULL);
 886   g_source_set_callback (input->source, (GSourceFunc)input_data_cb, input, NULL);
 887   g_source_attach (input->source, NULL);
 888
 889   /* Process any data in the pipe already */
 890   parse_input (input);
 891   process_input_messages (broadway_display);
 892
 893   g_strfreev (lines);
 894 }
 895
 896 static void
 897 start_output (HttpRequest *request, gboolean proto_v7_plus)
 898 {
 899   GSocket *socket;
 900   GdkBroadwayDisplay *broadway_display;
 901   int flag = 1;
 902
 903   socket = g_socket_connection_get_socket (request->connection);
 904   setsockopt(g_socket_get_fd (socket), IPPROTO_TCP,
 905              TCP_NODELAY, (char *) &flag, sizeof(int));
 906
 907   broadway_display = GDK_BROADWAY_DISPLAY (request->display);
 908
 909   if (broadway_display->output)
 910     {
 911       broadway_display->saved_serial = broadway_output_get_next_serial (broadway_display->output);
 912       broadway_output_free (broadway_display->output);
 913     }
 914
 915   broadway_display->output =
 916     broadway_output_new (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 917                          broadway_display->saved_serial, proto_v7_plus);
 918
 919   _gdk_broadway_resync_windows ();
 920
 921   if (broadway_display->pointer_grab_window)
 922     broadway_output_grab_pointer (broadway_display->output,
 923                                   GDK_WINDOW_IMPL_BROADWAY (broadway_display->pointer_grab_window->impl)->id,
 924                                   broadway_display->pointer_grab_owner_events);
 925 }
 926
 927 static void
 928 send_data (HttpRequest *request,
 929              const char *mimetype,
 930              const char *data, gsize len)
 931 {
 932   char *res;
 933
 934   res = g_strdup_printf ("HTTP/1.0 200 OK\r\n"
 935                          "Content-Type: %s\r\n"
 936                          "Content-Length: %"G_GSIZE_FORMAT"\r\n"
 937                          "\r\n",
 938                          mimetype, len);
 939   /* TODO: This should really be async */
 940   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 941                              res, strlen (res), NULL, NULL, NULL);
 942   g_free (res);
 943   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 944                              data, len, NULL, NULL, NULL);
 945   http_request_free (request);
 946 }
 947
 948 #include "clienthtml.h"
 949 #include "broadwayjs.h"
 950
 951 static void
 952 got_request (HttpRequest *request)
 953 {
 954   char *start, *escaped, *tmp, *version, *query;
 955
 956   if (!g_str_has_prefix (request->request->str, "GET "))
 957     {
 958       send_error (request, 501, "Only GET implemented");
 959       return;
 960     }
 961
 962   start = request->request->str + 4; /* Skip "GET " */
 963
 964   while (*start == ' ')
 965     start++;
 966
 967   for (tmp = start; *tmp != 0 && *tmp != ' ' && *tmp != '\n'; tmp++)
 968     ;
 969   escaped = g_strndup (start, tmp - start);
 970   version = NULL;
 971   if (*tmp == ' ')
 972     {
 973       start = tmp;
 974       while (*start == ' ')
 975         start++;
 976       for (tmp = start; *tmp != 0 && *tmp != ' ' && *tmp != '\n'; tmp++)
 977         ;
 978       version = g_strndup (start, tmp - start);
 979     }
 980
 981   query = strchr (escaped, '?');
 982   if (query)
 983     *query = 0;
 984
 985   if (strcmp (escaped, "/client.html") == 0 || strcmp (escaped, "/") == 0)
 986     send_data (request, "text/html", client_html, G_N_ELEMENTS(client_html) - 1);
 987   else if (strcmp (escaped, "/broadway.js") == 0)
 988     send_data (request, "text/javascript", broadway_js, G_N_ELEMENTS(broadway_js) - 1);
 989   else if (strcmp (escaped, "/socket") == 0)
 990     start_input (request);
 991   else
 992     send_error (request, 404, "File not found");
 993
 994   g_free (escaped);
 995   g_free (version);
 996 }
 997
 998 static void
 999 got_http_request_line (GInputStream *stream,
1000                        GAsyncResult *result,
1001                        HttpRequest *request)
1002 {
1003   char *line;
1004
1005   line = g_data_input_stream_read_line_finish (G_DATA_INPUT_STREAM (stream), result, NULL, NULL);
1006   if (line == NULL)
1007     {
1008       http_request_free (request);
1009       g_printerr ("Error reading request lines\n");
1010       return;
1011     }
1012   if (strlen (line) == 0)
1013     got_request (request);
1014   else
1015     {
1016       /* Protect against overflow in request length */
1017       if (request->request->len > 1024 * 5)
1018         {
1019           send_error (request, 400, "Request too long");
1020         }
1021       else
1022         {
1023           g_string_append_printf (request->request, "%s\n", line);
1024           g_data_input_stream_read_line_async (request->data, 0, NULL,
1025                                                (GAsyncReadyCallback)got_http_request_line, request);
1026         }
1027     }
1028   g_free (line);
1029 }
1030
1031 static gboolean
1032 handle_incoming_connection (GSocketService    *service,
1033                             GSocketConnection *connection,
1034                             GObject           *source_object)
1035 {
1036   HttpRequest *request;
1037   GInputStream *in;
1038
1039   request = g_new0 (HttpRequest, 1);
1040   request->connection = g_object_ref (connection);
1041   request->display = (GdkDisplay *) source_object;
1042   request->request = g_string_new ("");
1043
1044   in = g_io_stream_get_input_stream (G_IO_STREAM (connection));
1045
1046   request->data = g_data_input_stream_new (in);
1047   g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (request->data), FALSE);
1048   /* Be tolerant of input */
1049   g_data_input_stream_set_newline_type (request->data, G_DATA_STREAM_NEWLINE_TYPE_ANY);
1050
1051   g_data_input_stream_read_line_async (request->data, 0, NULL,
1052                                        (GAsyncReadyCallback)got_http_request_line, request);
1053   return TRUE;
1054 }
1055
1056 GdkDisplay *
1057 _gdk_broadway_display_open (const gchar *display_name)
1058 {
1059   GdkDisplay *display;
1060   GdkBroadwayDisplay *broadway_display;
1061   GError *error;
1062   int port;
1063
1064   display = g_object_new (GDK_TYPE_BROADWAY_DISPLAY, NULL);
1065   broadway_display = GDK_BROADWAY_DISPLAY (display);
1066
1067   broadway_display->output = NULL;
1068
1069   /* initialize the display's screens */
1070   broadway_display->screens = g_new (GdkScreen *, 1);
1071   broadway_display->screens[0] = _gdk_broadway_screen_new (display, 0);
1072
1073   /* We need to initialize events after we have the screen
1074    * structures in places
1075    */
1076   _gdk_broadway_screen_events_init (broadway_display->screens[0]);
1077
1078   /*set the default screen */
1079   broadway_display->default_screen = broadway_display->screens[0];
1080
1081   display->device_manager = _gdk_broadway_device_manager_new (display);
1082
1083   gdk_event_init (display);
1084
1085   gdk_broadway_display_init_input (display);
1086   _gdk_broadway_display_init_dnd (display);
1087
1088   _gdk_broadway_screen_setup (broadway_display->screens[0]);
1089
1090   if (display_name == NULL)
1091     display_name = g_getenv ("BROADWAY_DISPLAY");
1092
1093   port = 0;
1094   if (display_name != NULL)
1095     port = strtol(display_name, NULL, 10);
1096   if (port == 0)
1097     port = 8080;
1098
1099   broadway_display->service = g_socket_service_new ();
1100   if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (broadway_display->service),
1101                                         port,
1102                                         G_OBJECT (display),
1103                                         &error))
1104     {
1105       g_printerr ("Unable to listen to port %d: %s\n", 8080, error->message);
1106       g_error_free (error);
1107       return NULL;
1108     }
1109   g_signal_connect (broadway_display->service, "incoming", G_CALLBACK (handle_incoming_connection), NULL);
1110
1111   g_signal_emit_by_name (display, "opened");
1112   g_signal_emit_by_name (gdk_display_manager_get (), "display-opened", display);
1113
1114   return display;
1115 }
1116
1117
1118 static const gchar *
1119 gdk_broadway_display_get_name (GdkDisplay *display)
1120 {
1121   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
1122
1123   return (gchar *) "Broadway";
1124 }
1125
1126 static gint
1127 gdk_broadway_display_get_n_screens (GdkDisplay *display)
1128 {
1129   g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
1130
1131   return 1;
1132 }
1133
1134 static GdkScreen *
1135 gdk_broadway_display_get_screen (GdkDisplay *display,
1136                                  gint        screen_num)
1137 {
1138   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
1139   g_return_val_if_fail (screen_num == 0, NULL);
1140
1141   return GDK_BROADWAY_DISPLAY (display)->screens[screen_num];
1142 }
1143
1144 static GdkScreen *
1145 gdk_broadway_display_get_default_screen (GdkDisplay *display)
1146 {
1147   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
1148
1149   return GDK_BROADWAY_DISPLAY (display)->default_screen;
1150 }
1151
1152 static void
1153 gdk_broadway_display_beep (GdkDisplay *display)
1154 {
1155   g_return_if_fail (GDK_IS_DISPLAY (display));
1156 }
1157
1158 static void
1159 gdk_broadway_display_sync (GdkDisplay *display)
1160 {
1161   g_return_if_fail (GDK_IS_DISPLAY (display));
1162
1163 }
1164
1165 static void
1166 gdk_broadway_display_flush (GdkDisplay *display)
1167 {
1168   GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (display);
1169
1170   g_return_if_fail (GDK_IS_DISPLAY (display));
1171
1172   if (broadway_display->output &&
1173       !broadway_output_flush (broadway_display->output))
1174     {
1175       broadway_display->saved_serial = broadway_output_get_next_serial (broadway_display->output);
1176       broadway_output_free (broadway_display->output);
1177       broadway_display->output = NULL;
1178     }
1179 }
1180
1181 static gboolean
1182 gdk_broadway_display_has_pending (GdkDisplay *display)
1183 {
1184   return FALSE;
1185 }
1186
1187 static GdkWindow *
1188 gdk_broadway_display_get_default_group (GdkDisplay *display)
1189 {
1190   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
1191
1192   return NULL;
1193 }
1194
1195 static void
1196 gdk_broadway_display_dispose (GObject *object)
1197 {
1198   GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (object);
1199
1200   _gdk_broadway_display_manager_remove_display (gdk_display_manager_get (),
1201                                                 GDK_DISPLAY_OBJECT (object));
1202
1203   g_list_foreach (broadway_display->input_devices, (GFunc) g_object_run_dispose, NULL);
1204
1205   _gdk_screen_close (broadway_display->screens[0]);
1206
1207   if (broadway_display->event_source)
1208     {
1209       g_source_destroy (broadway_display->event_source);
1210       g_source_unref (broadway_display->event_source);
1211       broadway_display->event_source = NULL;
1212     }
1213
1214   G_OBJECT_CLASS (gdk_broadway_display_parent_class)->dispose (object);
1215 }
1216
1217 static void
1218 gdk_broadway_display_finalize (GObject *object)
1219 {
1220   GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (object);
1221
1222   /* Keymap */
1223   if (broadway_display->keymap)
1224     g_object_unref (broadway_display->keymap);
1225
1226   _gdk_broadway_cursor_display_finalize (GDK_DISPLAY_OBJECT(broadway_display));
1227
1228   /* input GdkDevice list */
1229   g_list_free_full (broadway_display->input_devices, g_object_unref);
1230   /* Free all GdkScreens */
1231   g_object_unref (broadway_display->screens[0]);
1232   g_free (broadway_display->screens);
1233
1234   G_OBJECT_CLASS (gdk_broadway_display_parent_class)->finalize (object);
1235 }
1236
1237 void
1238 _gdk_broadway_display_make_default (GdkDisplay *display)
1239 {
1240 }
1241
1242 static void
1243 gdk_broadway_display_notify_startup_complete (GdkDisplay  *display,
1244                                               const gchar *startup_id)
1245 {
1246 }
1247
1248 static gboolean
1249 gdk_broadway_display_supports_selection_notification (GdkDisplay *display)
1250 {
1251   return FALSE;
1252 }
1253
1254 static gboolean
1255 gdk_broadway_display_request_selection_notification (GdkDisplay *display,
1256                                                      GdkAtom     selection)
1257
1258 {
1259     return FALSE;
1260 }
1261
1262 static gboolean
1263 gdk_broadway_display_supports_clipboard_persistence (GdkDisplay *display)
1264 {
1265   return FALSE;
1266 }
1267
1268 static void
1269 gdk_broadway_display_store_clipboard (GdkDisplay    *display,
1270                                       GdkWindow     *clipboard_window,
1271                                       guint32        time_,
1272                                       const GdkAtom *targets,
1273                                       gint           n_targets)
1274 {
1275 }
1276
1277 static gboolean
1278 gdk_broadway_display_supports_shapes (GdkDisplay *display)
1279 {
1280   return FALSE;
1281 }
1282
1283 static gboolean
1284 gdk_broadway_display_supports_input_shapes (GdkDisplay *display)
1285 {
1286   return FALSE;
1287 }
1288
1289 static gboolean
1290 gdk_broadway_display_supports_composite (GdkDisplay *display)
1291 {
1292   return FALSE;
1293 }
1294
1295 static GList *
1296 gdk_broadway_display_list_devices (GdkDisplay *display)
1297 {
1298   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
1299
1300   return GDK_BROADWAY_DISPLAY (display)->input_devices;
1301 }
1302
1303 static gulong
1304 gdk_broadway_display_get_next_serial (GdkDisplay *display)
1305 {
1306   GdkBroadwayDisplay *broadway_display;
1307   broadway_display = GDK_BROADWAY_DISPLAY (display);
1308   if (broadway_display->output)
1309     return broadway_output_get_next_serial (broadway_display->output);
1310   return broadway_display->saved_serial;
1311 }
1312
1313
1314 static void
1315 gdk_broadway_display_event_data_copy (GdkDisplay    *display,
1316                                       const GdkEvent *src,
1317                                       GdkEvent       *dst)
1318 {
1319 }
1320
1321 static void
1322 gdk_broadway_display_event_data_free (GdkDisplay    *display,
1323                                       GdkEvent *event)
1324 {
1325 }
1326
1327 static void
1328 gdk_broadway_display_class_init (GdkBroadwayDisplayClass * class)
1329 {
1330   GObjectClass *object_class = G_OBJECT_CLASS (class);
1331   GdkDisplayClass *display_class = GDK_DISPLAY_CLASS (class);
1332
1333   object_class->dispose = gdk_broadway_display_dispose;
1334   object_class->finalize = gdk_broadway_display_finalize;
1335
1336   display_class->window_type = GDK_TYPE_BROADWAY_WINDOW;
1337
1338   display_class->get_name = gdk_broadway_display_get_name;
1339   display_class->get_n_screens = gdk_broadway_display_get_n_screens;
1340   display_class->get_screen = gdk_broadway_display_get_screen;
1341   display_class->get_default_screen = gdk_broadway_display_get_default_screen;
1342   display_class->beep = gdk_broadway_display_beep;
1343   display_class->sync = gdk_broadway_display_sync;
1344   display_class->flush = gdk_broadway_display_flush;
1345   display_class->has_pending = gdk_broadway_display_has_pending;
1346   display_class->queue_events = _gdk_broadway_display_queue_events;
1347   display_class->get_default_group = gdk_broadway_display_get_default_group;
1348   display_class->supports_selection_notification = gdk_broadway_display_supports_selection_notification;
1349   display_class->request_selection_notification = gdk_broadway_display_request_selection_notification;
1350   display_class->supports_clipboard_persistence = gdk_broadway_display_supports_clipboard_persistence;
1351   display_class->store_clipboard = gdk_broadway_display_store_clipboard;
1352   display_class->supports_shapes = gdk_broadway_display_supports_shapes;
1353   display_class->supports_input_shapes = gdk_broadway_display_supports_input_shapes;
1354   display_class->supports_composite = gdk_broadway_display_supports_composite;
1355   display_class->list_devices = gdk_broadway_display_list_devices;
1356   display_class->get_cursor_for_type = _gdk_broadway_display_get_cursor_for_type;
1357   display_class->get_cursor_for_name = _gdk_broadway_display_get_cursor_for_name;
1358   display_class->get_cursor_for_pixbuf = _gdk_broadway_display_get_cursor_for_pixbuf;
1359   display_class->get_default_cursor_size = _gdk_broadway_display_get_default_cursor_size;
1360   display_class->get_maximal_cursor_size = _gdk_broadway_display_get_maximal_cursor_size;
1361   display_class->supports_cursor_alpha = _gdk_broadway_display_supports_cursor_alpha;
1362   display_class->supports_cursor_color = _gdk_broadway_display_supports_cursor_color;
1363
1364   display_class->before_process_all_updates = _gdk_broadway_display_before_process_all_updates;
1365   display_class->after_process_all_updates = _gdk_broadway_display_after_process_all_updates;
1366   display_class->get_next_serial = gdk_broadway_display_get_next_serial;
1367   display_class->notify_startup_complete = gdk_broadway_display_notify_startup_complete;
1368   display_class->event_data_copy = gdk_broadway_display_event_data_copy;
1369   display_class->event_data_free = gdk_broadway_display_event_data_free;
1370   display_class->create_window_impl = _gdk_broadway_display_create_window_impl;
1371   display_class->get_keymap = _gdk_broadway_display_get_keymap;
1372   display_class->get_selection_owner = _gdk_broadway_display_get_selection_owner;
1373   display_class->set_selection_owner = _gdk_broadway_display_set_selection_owner;
1374   display_class->send_selection_notify = _gdk_broadway_display_send_selection_notify;
1375   display_class->get_selection_property = _gdk_broadway_display_get_selection_property;
1376   display_class->convert_selection = _gdk_broadway_display_convert_selection;
1377   display_class->text_property_to_utf8_list = _gdk_broadway_display_text_property_to_utf8_list;
1378   display_class->utf8_to_string_target = _gdk_broadway_display_utf8_to_string_target;
1379 }
1380