tests/get.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2001-2003, Ximian, Inc.
   4  */
   5
   6 #ifdef HAVE_CONFIG_H
   7 #include <config.h>
   8 #endif
   9
  10 #include <ctype.h>
  11 #include <errno.h>
  12 #include <fcntl.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <sys/stat.h>
  17 #include <unistd.h>
  18
  19 #include <libsoup/soup.h>
  20
  21 static SoupSession *session;
  22 static GMainLoop *loop;
  23 static gboolean debug = FALSE, quiet = FALSE;
  24 static const char *method;
  25
  26 static void
  27 get_url (const char *url)
  28 {
  29         const char *name;
  30         SoupMessage *msg;
  31         const char *header;
  32
  33         msg = soup_message_new (method, url);
  34         soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
  35
  36         soup_session_send_message (session, msg);
  37
  38         name = soup_message_get_uri (msg)->path;
  39
  40         if (debug) {
  41                 SoupMessageHeadersIter iter;
  42                 const char *hname, *value;
  43                 char *path = soup_uri_to_string (soup_message_get_uri (msg), TRUE);
  44
  45                 printf ("%s %s HTTP/1.%d\n", method, path,
  46                         soup_message_get_http_version (msg));
  47                 soup_message_headers_iter_init (&iter, msg->request_headers);
  48                 while (soup_message_headers_iter_next (&iter, &hname, &value))
  49                         printf ("%s: %s\r\n", hname, value);
  50                 printf ("\n");
  51
  52                 printf ("HTTP/1.%d %d %s\n",
  53                         soup_message_get_http_version (msg),
  54                         msg->status_code, msg->reason_phrase);
  55
  56                 soup_message_headers_iter_init (&iter, msg->response_headers);
  57                 while (soup_message_headers_iter_next (&iter, &hname, &value))
  58                         printf ("%s: %s\r\n", hname, value);
  59                 printf ("\n");
  60         } else if (msg->status_code == SOUP_STATUS_SSL_FAILED) {
  61                 GTlsCertificateFlags flags;
  62
  63                 if (soup_message_get_https_status (msg, NULL, &flags))
  64                         printf ("%s: %d %s (0x%x)\n", name, msg->status_code, msg->reason_phrase, flags);
  65                 else
  66                         printf ("%s: %d %s (no handshake status)\n", name, msg->status_code, msg->reason_phrase);
  67         } else if (!quiet || SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code))
  68                 printf ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
  69
  70         if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
  71                 header = soup_message_headers_get_one (msg->response_headers,
  72                                                        "Location");
  73                 if (header) {
  74                         SoupURI *uri;
  75                         char *uri_string;
  76
  77                         if (!debug && !quiet)
  78                                 printf ("  -> %s\n", header);
  79
  80                         uri = soup_uri_new_with_base (soup_message_get_uri (msg), header);
  81                         uri_string = soup_uri_to_string (uri, FALSE);
  82                         get_url (uri_string);
  83                         g_free (uri_string);
  84                         soup_uri_free (uri);
  85                 }
  86         } else if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
  87                 fwrite (msg->response_body->data, 1,
  88                         msg->response_body->length, stdout);
  89         }
  90 }
  91
  92 static void
  93 usage (void)
  94 {
  95         fprintf (stderr, "Usage: get [-c CAfile] [-p proxy URL] [-h] [-d] URL\n");
  96         exit (1);
  97 }
  98
  99 int
 100 main (int argc, char **argv)
 101 {
 102         const char *cafile = NULL, *url;
 103         SoupURI *proxy = NULL, *parsed;
 104         gboolean synchronous = FALSE, ntlm = FALSE;
 105         int opt;
 106
 107         g_type_init ();
 108
 109         method = SOUP_METHOD_GET;
 110
 111         while ((opt = getopt (argc, argv, "c:dhnp:qs")) != -1) {
 112                 switch (opt) {
 113                 case 'c':
 114                         cafile = optarg;
 115                         break;
 116
 117                 case 'd':
 118                         debug = TRUE;
 119                         break;
 120
 121                 case 'h':
 122                         method = SOUP_METHOD_HEAD;
 123                         debug = TRUE;
 124                         break;
 125
 126                 case 'n':
 127                         ntlm = TRUE;
 128                         break;
 129
 130                 case 'p':
 131                         proxy = soup_uri_new (optarg);
 132                         if (!proxy) {
 133                                 fprintf (stderr, "Could not parse %s as URI\n",
 134                                          optarg);
 135                                 exit (1);
 136                         }
 137                         break;
 138
 139                 case 'q':
 140                         quiet = TRUE;
 141                         break;
 142
 143                 case 's':
 144                         synchronous = TRUE;
 145                         break;
 146
 147                 case '?':
 148                         usage ();
 149                         break;
 150                 }
 151         }
 152         argc -= optind;
 153         argv += optind;
 154
 155         if (argc != 1)
 156                 usage ();
 157         url = argv[0];
 158         parsed = soup_uri_new (url);
 159         if (!parsed) {
 160                 fprintf (stderr, "Could not parse '%s' as a URL\n", url);
 161                 exit (1);
 162         }
 163         soup_uri_free (parsed);
 164
 165         if (synchronous) {
 166                 session = soup_session_sync_new_with_options (
 167                         SOUP_SESSION_SSL_CA_FILE, cafile,
 168                         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
 169                         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
 170                         SOUP_SESSION_USER_AGENT, "get ",
 171                         SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
 172                         SOUP_SESSION_USE_NTLM, ntlm,
 173                         NULL);
 174         } else {
 175                 session = soup_session_async_new_with_options (
 176                         SOUP_SESSION_SSL_CA_FILE, cafile,
 177                         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
 178                         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
 179                         SOUP_SESSION_USER_AGENT, "get ",
 180                         SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
 181                         SOUP_SESSION_USE_NTLM, ntlm,
 182                         NULL);
 183         }
 184
 185         if (proxy) {
 186                 g_object_set (G_OBJECT (session),
 187                               SOUP_SESSION_PROXY_URI, proxy,
 188                               NULL);
 189         } else
 190                 soup_session_add_feature_by_type (session, SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
 191
 192         if (!synchronous)
 193                 loop = g_main_loop_new (NULL, TRUE);
 194
 195         get_url (url);
 196
 197         if (!synchronous)
 198                 g_main_loop_unref (loop);
 199
 200         return 0;
 201 }