Re: [gupnp] handling of sequence numbers in gupnp-service-proxy.c

[Sven Neumann <s neumann phase-zero de>]

Hi,

attached is a slightly modified version of the test code. I've added a
few signal handlers that spit out some debug output in order to track
how the messages are processed on the sender side. The typical output
looks like this:

 queued message 1
 queued message 2
 queued message 3
 queued message 4
 queued message 5
 queued message 6
 queued message 7
 queued message 8
 queued message 9
 queued message 10
 queued message 11
 queued message 12
 queued message 13
 queued message 14
 queued message 15
 queued message 16
 queued message 17
 queued message 18
 queued message 19
 queued message 20
 started message 1
 started message 2
 received message 2
 finished message 2
 started message 3
 received message 1

Even though I am not convinced that libsoup should behave differently,
I'll open a bug report against libsoup and attach the test case. Will
keep you informed...


Sven

//============================================================================
// Name        : Outrunner.c
// Author      :
// Version     :
// Copyright   : Your copyright notice
// Description : Proof of two soup messages, outrunning each other
//============================================================================

#include <stdio.h>
#include <stdlib.h>

#include <glib.h>

#include <libsoup/soup.h>

static GMainLoop *theMainLoop          = NULL;
static int        latestReceivedNumber = 0;
static int        latestSentNumber     = 0;
static guint      port                 = 49152; // first port to try


static void
server_callback (SoupServer  *soup_server,
                 SoupMessage *msg)
{
  const char *sequenceNumber;
  int         number;

  sequenceNumber = soup_message_headers_get (msg->request_headers,
                                             "SequenceNumber");
  number = atoi (sequenceNumber);

  g_printerr (" received message %d\n", number);
  g_assert (number > latestReceivedNumber);

  latestReceivedNumber = number;
}

static void
session_request_queued (SoupSession *session,
                        SoupMessage *msg)
{
  g_printerr (" queued message %s\n",
              soup_message_headers_get (msg->request_headers,
                                        "SequenceNumber"));

}

static void
session_request_started (SoupSession *session,
                         SoupMessage *msg)
{
  g_printerr (" started message %s\n",
              soup_message_headers_get (msg->request_headers,
                                        "SequenceNumber"));

}

static void
message_finished (SoupMessage *msg)
{
  g_printerr (" finished message %s\n",
              soup_message_headers_get (msg->request_headers,
                                        "SequenceNumber"));  
}

static gboolean
queueSomeMessages (SoupSession *session)
{
  GRand *rand = g_rand_new_with_seed (time (NULL));
  gint   i;
  char   txt[128];

  for (i = 0; i < 10; i++)
    {
      SoupMessage *msg;
      int          len;

      sprintf (txt, "http://localhost:%d";, port);
      msg = soup_message_new ("GET", txt);

      sprintf (txt, "%d", ++latestSentNumber);
      soup_message_headers_append (msg->request_headers, "SequenceNumber", txt);

      // append a body with random length
      len = g_rand_int_range (rand, 10, 1024 * 1024 * 5);
      soup_message_body_append (msg->request_body,
                                SOUP_MEMORY_TAKE, g_malloc (len), len);

      g_signal_connect (msg, "finished",
                        G_CALLBACK (message_finished),
                        NULL);

      soup_session_queue_message (session, msg, NULL, NULL);
    }

  g_rand_free (rand);

  return TRUE; // infinite, until the error occurs
}

static void
quit (int sig)
{
  if (theMainLoop)
    {
      g_main_loop_quit (theMainLoop);
      theMainLoop = NULL;
    }
}

int
main (void)
{
  SoupServer  *server;
  SoupSession *session;

  signal(SIGINT, quit);

  g_type_init ();
  g_thread_init (NULL);

  do
    {
      server = soup_server_new (SOUP_SERVER_PORT, ++port, NULL);
    }
  while (!server && port < 55000);

  if (server)
    {
      soup_server_add_handler (server, NULL,
                               (SoupServerCallback) server_callback,
                               NULL, NULL);
      soup_server_run_async (server);
    }

  session = soup_session_async_new ();

  g_signal_connect (session, "request-queued",
                    G_CALLBACK (session_request_queued),
                    NULL);
  g_signal_connect (session, "request-started",
                    G_CALLBACK (session_request_started),
                    NULL);

  theMainLoop = g_main_loop_new (NULL, FALSE);
  g_idle_add ((GSourceFunc) &queueSomeMessages, session);

  g_main_loop_run (theMainLoop);
  g_main_loop_unref (theMainLoop);

  return EXIT_SUCCESS;
}