url-http.el 56.6 KB
Newer Older
Stefan Monnier's avatar
Stefan Monnier committed
1
;;; url-http.el --- HTTP retrieval routines
2

3
;; Copyright (C) 1999, 2001, 2004-2011  Free Software Foundation, Inc.
4

Stefan Monnier's avatar
Stefan Monnier committed
5 6
;; Author: Bill Perry <wmperry@gnu.org>
;; Keywords: comm, data, processes
7

8 9
;; This file is part of GNU Emacs.
;;
10
;; GNU Emacs is free software: you can redistribute it and/or modify
11
;; it under the terms of the GNU General Public License as published by
12 13 14
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

15 16 17 18
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
19

20
;; You should have received a copy of the GNU General Public License
21
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
Stefan Monnier's avatar
Stefan Monnier committed
22

23 24 25
;;; Commentary:

;;; Code:
Stefan Monnier's avatar
Stefan Monnier committed
26

Stefan Monnier's avatar
Stefan Monnier committed
27 28 29
(eval-when-compile (require 'cl))
(defvar url-http-extra-headers)
(defvar url-http-target-url)
30
(defvar url-http-proxy)
31
(defvar url-http-connection-opened)
Stefan Monnier's avatar
Stefan Monnier committed
32 33 34 35 36 37
(require 'url-gw)
(require 'url-util)
(require 'url-parse)
(require 'url-cookie)
(require 'mail-parse)
(require 'url-auth)
38
(require 'url)
Stefan Monnier's avatar
Stefan Monnier committed
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
(autoload 'url-cache-create-filename "url-cache")

(defconst url-http-default-port 80 "Default HTTP port.")
(defconst url-http-asynchronous-p t "HTTP retrievals are asynchronous.")
(defalias 'url-http-expand-file-name 'url-default-expander)

(defvar url-http-real-basic-auth-storage nil)
(defvar url-http-proxy-basic-auth-storage nil)

(defvar url-http-open-connections (make-hash-table :test 'equal
						   :size 17)
  "A hash table of all open network connections.")

(defvar url-http-version "1.1"
  "What version of HTTP we advertise, as a string.
Valid values are 1.1 and 1.0.
This is only useful when debugging the HTTP subsystem.

Setting this to 1.0 will tell servers not to send chunked encoding,
58
and other HTTP/1.1 specific features.")
Stefan Monnier's avatar
Stefan Monnier committed
59 60 61 62

(defvar url-http-attempt-keepalives t
  "Whether to use a single TCP connection multiple times in HTTP.
This is only useful when debugging the HTTP subsystem.  Setting to
63 64
nil will explicitly close the connection to the server after every
request.")
Stefan Monnier's avatar
Stefan Monnier committed
65

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
(defconst url-http-codes
  '((100 continue                        "Continue with request")
    (101 switching-protocols             "Switching protocols")
    (102 processing                      "Processing (Added by DAV)")
    (200 OK                              "OK")
    (201 created                         "Created")
    (202 accepted                        "Accepted")
    (203 non-authoritative               "Non-authoritative information")
    (204 no-content                      "No content")
    (205 reset-content                   "Reset content")
    (206 partial-content                 "Partial content")
    (207 multi-status                    "Multi-status (Added by DAV)")
    (300 multiple-choices                "Multiple choices")
    (301 moved-permanently               "Moved permanently")
    (302 found                           "Found")
    (303 see-other                       "See other")
    (304 not-modified                    "Not modified")
    (305 use-proxy                       "Use proxy")
    (307 temporary-redirect              "Temporary redirect")
    (400 bad-request                     "Bad Request")
    (401 unauthorized                    "Unauthorized")
    (402 payment-required                "Payment required")
    (403 forbidden                       "Forbidden")
    (404 not-found                       "Not found")
    (405 method-not-allowed              "Method not allowed")
    (406 not-acceptable                  "Not acceptable")
    (407 proxy-authentication-required   "Proxy authentication required")
    (408 request-timeout                 "Request time-out")
    (409 conflict                        "Conflict")
    (410 gone                            "Gone")
    (411 length-required                 "Length required")
    (412 precondition-failed             "Precondition failed")
    (413 request-entity-too-large        "Request entity too large")
    (414 request-uri-too-large           "Request-URI too large")
    (415 unsupported-media-type          "Unsupported media type")
    (416 requested-range-not-satisfiable "Requested range not satisfiable")
    (417 expectation-failed              "Expectation failed")
    (422 unprocessable-entity            "Unprocessable Entity (Added by DAV)")
    (423 locked                          "Locked")
    (424 failed-Dependency               "Failed Dependency")
    (500 internal-server-error           "Internal server error")
    (501 not-implemented                 "Not implemented")
    (502 bad-gateway                     "Bad gateway")
    (503 service-unavailable             "Service unavailable")
    (504 gateway-timeout                 "Gateway time-out")
    (505 http-version-not-supported      "HTTP version not supported")
    (507 insufficient-storage            "Insufficient storage")
"The HTTP return codes and their text."))

Stefan Monnier's avatar
Stefan Monnier committed
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
;(eval-when-compile
;; These are all macros so that they are hidden from external sight
;; when the file is byte-compiled.
;;
;; This allows us to expose just the entry points we want.

;; These routines will allow us to implement persistent HTTP
;; connections.
(defsubst url-http-debug (&rest args)
  (if quit-flag
      (let ((proc (get-buffer-process (current-buffer))))
	;; The user hit C-g, honor it!  Some things can get in an
	;; incredibly tight loop (chunked encoding)
	(if proc
	    (progn
	      (set-process-sentinel proc nil)
	      (set-process-filter proc nil)))
	(error "Transfer interrupted!")))
  (apply 'url-debug 'http args))

(defun url-http-mark-connection-as-busy (host port proc)
  (url-http-debug "Marking connection as busy: %s:%d %S" host port proc)
137
  (set-process-query-on-exit-flag proc t)
Stefan Monnier's avatar
Stefan Monnier committed
138 139 140 141 142 143 144
  (puthash (cons host port)
	      (delq proc (gethash (cons host port) url-http-open-connections))
	      url-http-open-connections)
  proc)

(defun url-http-mark-connection-as-free (host port proc)
  (url-http-debug "Marking connection as free: %s:%d %S" host port proc)
145
  (when (memq (process-status proc) '(open run connect))
146 147
    (set-process-buffer proc nil)
    (set-process-sentinel proc 'url-http-idle-sentinel)
148
    (set-process-query-on-exit-flag proc nil)
149 150 151
    (puthash (cons host port)
	     (cons proc (gethash (cons host port) url-http-open-connections))
	     url-http-open-connections))
Stefan Monnier's avatar
Stefan Monnier committed
152 153 154 155 156 157
  nil)

(defun url-http-find-free-connection (host port)
  (let ((conns (gethash (cons host port) url-http-open-connections))
	(found nil))
    (while (and conns (not found))
158
      (if (not (memq (process-status (car conns)) '(run open connect)))
Stefan Monnier's avatar
Stefan Monnier committed
159 160 161 162 163 164 165 166 167 168 169
	  (progn
	    (url-http-debug "Cleaning up dead process: %s:%d %S"
			    host port (car conns))
	    (url-http-idle-sentinel (car conns) nil))
	(setq found (car conns))
	(url-http-debug "Found existing connection: %s:%d %S" host port found))
      (pop conns))
    (if found
	(url-http-debug "Reusing existing connection: %s:%d" host port)
      (url-http-debug "Contacting host: %s:%d" host port))
    (url-lazy-message "Contacting host: %s:%d" host port)
170 171 172 173 174 175
    (url-http-mark-connection-as-busy
     host port
     (or found
         (let ((buf (generate-new-buffer " *url-http-temp*")))
           ;; `url-open-stream' needs a buffer in which to do things
           ;; like authentication.  But we use another buffer afterwards.
176 177
           (unwind-protect
               (let ((proc (url-open-stream host buf host port)))
178 179 180 181
		 ;; url-open-stream might return nil.
		 (when (processp proc)
		   ;; Drop the temp buffer link before killing the buffer.
		   (set-process-buffer proc nil))
182
                 proc)
183
             (kill-buffer buf)))))))
Stefan Monnier's avatar
Stefan Monnier committed
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202

;; Building an HTTP request
(defun url-http-user-agent-string ()
  (if (or (eq url-privacy-level 'paranoid)
	  (and (listp url-privacy-level)
	       (memq 'agent url-privacy-level)))
      ""
    (format "User-Agent: %sURL/%s%s\r\n"
	    (if url-package-name
		(concat url-package-name "/" url-package-version " ")
	      "")
	    url-version
	    (cond
	     ((and url-os-type url-system-type)
	      (concat " (" url-os-type "; " url-system-type ")"))
	     ((or url-os-type url-system-type)
	      (concat " (" (or url-system-type url-os-type) ")"))
	     (t "")))))

203 204
(defun url-http-create-request (&optional ref-url)
  "Create an HTTP request for `url-http-target-url', referred to by REF-URL."
Juanma Barranquero's avatar
Juanma Barranquero committed
205
  (declare (special proxy-info
206 207
		    url-http-method url-http-data
		    url-http-extra-headers))
Stefan Monnier's avatar
Stefan Monnier committed
208 209
  (let* ((extra-headers)
	 (request nil)
210
	 (no-cache (cdr-safe (assoc "Pragma" url-http-extra-headers)))
211
	 (using-proxy url-http-proxy)
Stefan Monnier's avatar
Stefan Monnier committed
212
	 (proxy-auth (if (or (cdr-safe (assoc "Proxy-Authorization"
213
					      url-http-extra-headers))
214
			     (not using-proxy))
Stefan Monnier's avatar
Stefan Monnier committed
215 216 217
			 nil
		       (let ((url-basic-auth-storage
			      'url-http-proxy-basic-auth-storage))
218 219 220 221
			 (url-get-authentication url-http-target-url nil 'any nil))))
	 (real-fname (concat (url-filename url-http-target-url)
			     (url-recreate-url-attributes url-http-target-url)))
	 (host (url-host url-http-target-url))
222
	 (auth (if (cdr-safe (assoc "Authorization" url-http-extra-headers))
Stefan Monnier's avatar
Stefan Monnier committed
223 224 225 226
		   nil
		 (url-get-authentication (or
					  (and (boundp 'proxy-info)
					       proxy-info)
227
					  url-http-target-url) nil 'any nil))))
Stefan Monnier's avatar
Stefan Monnier committed
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
    (if (equal "" real-fname)
	(setq real-fname "/"))
    (setq no-cache (and no-cache (string-match "no-cache" no-cache)))
    (if auth
	(setq auth (concat "Authorization: " auth "\r\n")))
    (if proxy-auth
	(setq proxy-auth (concat "Proxy-Authorization: " proxy-auth "\r\n")))

    ;; Protection against stupid values in the referer
    (if (and ref-url (stringp ref-url) (or (string= ref-url "file:nil")
					   (string= ref-url "")))
	(setq ref-url nil))

    ;; We do not want to expose the referer if the user is paranoid.
    (if (or (memq url-privacy-level '(low high paranoid))
	    (and (listp url-privacy-level)
		 (memq 'lastloc url-privacy-level)))
	(setq ref-url nil))

247
    ;; url-http-extra-headers contains an assoc-list of
Stefan Monnier's avatar
Stefan Monnier committed
248 249 250 251
    ;; header/value pairs that we need to put into the request.
    (setq extra-headers (mapconcat
			 (lambda (x)
			   (concat (car x) ": " (cdr x)))
252
			 url-http-extra-headers "\r\n"))
Stefan Monnier's avatar
Stefan Monnier committed
253 254 255 256
    (if (not (equal extra-headers ""))
	(setq extra-headers (concat extra-headers "\r\n")))

    ;; This was done with a call to `format'.  Concatting parts has
257
    ;; the advantage of keeping the parts of each header together and
Stefan Monnier's avatar
Stefan Monnier committed
258 259 260
    ;; allows us to elide null lines directly, at the cost of making
    ;; the layout less clear.
    (setq request
261 262 263 264 265 266 267 268 269 270 271 272 273 274
          ;; We used to concat directly, but if one of the strings happens
          ;; to being multibyte (even if it only contains pure ASCII) then
          ;; every string gets converted with `string-MAKE-multibyte' which
          ;; turns the 127-255 codes into things like latin-1 accented chars
          ;; (it would work right if it used `string-TO-multibyte' instead).
          ;; So to avoid the problem we force every string to be unibyte.
          (mapconcat
           ;; FIXME: Instead of `string-AS-unibyte' we'd want
           ;; `string-to-unibyte', so as to properly signal an error if one
           ;; of the strings contains a multibyte char.
           'string-as-unibyte
           (delq nil
            (list
             ;; The request
275
             (or url-http-method "GET") " "
276
             (if using-proxy (url-recreate-url url-http-target-url) real-fname)
277 278 279 280
             " HTTP/" url-http-version "\r\n"
             ;; Version of MIME we speak
             "MIME-Version: 1.0\r\n"
             ;; (maybe) Try to keep the connection open
281
             "Connection: " (if (or using-proxy
282 283 284 285 286 287 288
                                    (not url-http-attempt-keepalives))
                                "close" "keep-alive") "\r\n"
                                ;; HTTP extensions we support
             (if url-extensions-header
                 (format
                  "Extension: %s\r\n" url-extensions-header))
             ;; Who we want to talk to
289
             (if (/= (url-port url-http-target-url)
290
                     (url-scheme-get-property
291
                      (url-type url-http-target-url) 'default-port))
292
                 (format
293
                  "Host: %s:%d\r\n" host (url-port url-http-target-url))
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
               (format "Host: %s\r\n" host))
             ;; Who its from
             (if url-personal-mail-address
                 (concat
                  "From: " url-personal-mail-address "\r\n"))
             ;; Encodings we understand
             (if url-mime-encoding-string
                 (concat
                  "Accept-encoding: " url-mime-encoding-string "\r\n"))
             (if url-mime-charset-string
                 (concat
                  "Accept-charset: " url-mime-charset-string "\r\n"))
             ;; Languages we understand
             (if url-mime-language-string
                 (concat
                  "Accept-language: " url-mime-language-string "\r\n"))
             ;; Types we understand
             "Accept: " (or url-mime-accept-string "*/*") "\r\n"
             ;; User agent
             (url-http-user-agent-string)
             ;; Proxy Authorization
             proxy-auth
             ;; Authorization
             auth
             ;; Cookies
             (url-cookie-generate-header-lines host real-fname
320
                                               (equal "https" (url-type url-http-target-url)))
321 322
             ;; If-modified-since
             (if (and (not no-cache)
323
                      (member url-http-method '("GET" nil)))
324
                 (let ((tm (url-is-cached url-http-target-url)))
325 326 327 328 329 330 331 332
                   (if tm
                       (concat "If-modified-since: "
                               (url-get-normalized-date tm) "\r\n"))))
             ;; Whence we came
             (if ref-url (concat
                          "Referer: " ref-url "\r\n"))
             extra-headers
             ;; Length of data
333
             (if url-http-data
334 335
                 (concat
                  "Content-length: " (number-to-string
336
                                      (length url-http-data))
337 338 339 340
                  "\r\n"))
             ;; End request
             "\r\n"
             ;; Any data
341
             url-http-data))
342
           ""))
Stefan Monnier's avatar
Stefan Monnier committed
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
    (url-http-debug "Request is: \n%s" request)
    request))

;; Parsing routines
(defun url-http-clean-headers ()
  "Remove trailing \r from header lines.
This allows us to use `mail-fetch-field', etc."
  (declare (special url-http-end-of-headers))
  (goto-char (point-min))
  (while (re-search-forward "\r$" url-http-end-of-headers t)
    (replace-match "")))

(defun url-http-handle-authentication (proxy)
  (declare (special status success url-http-method url-http-data
		    url-callback-function url-callback-arguments))
  (url-http-debug "Handling %s authentication" (if proxy "proxy" "normal"))
359 360 361 362 363
  (let ((auths (or (nreverse
		    (mail-fetch-field
		     (if proxy "proxy-authenticate" "www-authenticate")
		     nil nil t))
		  '("basic")))
Stefan Monnier's avatar
Stefan Monnier committed
364 365
	(type nil)
	(url (url-recreate-url url-current-object))
366 367 368 369 370 371 372 373
	(auth-url (url-recreate-url
		   (if (and proxy (boundp 'url-http-proxy))
		       url-http-proxy
		     url-current-object)))
	(url-basic-auth-storage (if proxy
				    ;; Cheating, but who cares? :)
				    'url-http-proxy-basic-auth-storage
				  'url-http-real-basic-auth-storage))
374 375
	auth
	(strength 0))
Stefan Monnier's avatar
Stefan Monnier committed
376

377 378
    ;; find strongest supported auth
    (dolist (this-auth auths)
Juanma Barranquero's avatar
Juanma Barranquero committed
379 380
      (setq this-auth (url-eat-trailing-space
		       (url-strip-leading-spaces
381
			this-auth)))
Juanma Barranquero's avatar
Juanma Barranquero committed
382
      (let* ((this-type
383 384 385 386 387 388 389 390 391
	      (if (string-match "[ \t]" this-auth)
		  (downcase (substring this-auth 0 (match-beginning 0)))
		(downcase this-auth)))
	     (registered (url-auth-registered this-type))
	     (this-strength (cddr registered)))
	(when (and registered (> this-strength strength))
	  (setq auth this-auth
		type this-type
		strength this-strength))))
Stefan Monnier's avatar
Stefan Monnier committed
392 393 394 395 396 397 398 399 400

    (if (not (url-auth-registered type))
	(progn
	  (widen)
	  (goto-char (point-max))
	  (insert "<hr>Sorry, but I do not know how to handle " type
		  " authentication.  If you'd like to write it,"
		  " send it to " url-bug-address ".<hr>")
	  (setq status t))
Stefan Monnier's avatar
Stefan Monnier committed
401
      (let* ((args (url-parse-args (subst-char-in-string ?, ?\; auth)))
402 403
	     (auth (url-get-authentication auth-url
					   (cdr-safe (assoc "realm" args))
Stefan Monnier's avatar
Stefan Monnier committed
404
					   type t args)))
Stefan Monnier's avatar
Stefan Monnier committed
405 406 407 408 409 410 411
	(if (not auth)
	    (setq success t)
	  (push (cons (if proxy "Proxy-Authorization" "Authorization") auth)
		url-http-extra-headers)
	  (let ((url-request-method url-http-method)
		(url-request-data url-http-data)
		(url-request-extra-headers url-http-extra-headers))
412 413
	    (url-retrieve-internal url url-callback-function
				   url-callback-arguments)))))))
Stefan Monnier's avatar
Stefan Monnier committed
414 415 416

(defun url-http-parse-response ()
  "Parse just the response code."
417 418
  (declare (special url-http-end-of-headers url-http-response-status
		    url-http-response-version))
Stefan Monnier's avatar
Stefan Monnier committed
419 420 421 422 423 424
  (if (not url-http-end-of-headers)
      (error "Trying to parse HTTP response code in odd buffer: %s" (buffer-name)))
  (url-http-debug "url-http-parse-response called in (%s)" (buffer-name))
  (goto-char (point-min))
  (skip-chars-forward " \t\n")		; Skip any blank crap
  (skip-chars-forward "HTTP/")		; Skip HTTP Version
425 426 427 428 429
  (setq url-http-response-version
	(buffer-substring (point)
			  (progn
			    (skip-chars-forward "[0-9].")
			    (point))))
Stefan Monnier's avatar
Stefan Monnier committed
430 431 432 433
  (setq url-http-response-status (read (current-buffer))))

(defun url-http-handle-cookies ()
  "Handle all set-cookie / set-cookie2 headers in an HTTP response.
434
The buffer must already be narrowed to the headers, so `mail-fetch-field' will
Stefan Monnier's avatar
Stefan Monnier committed
435
work correctly."
436 437
  (let ((cookies (nreverse (mail-fetch-field "Set-Cookie" nil nil t)))
	(cookies2 (nreverse (mail-fetch-field "Set-Cookie2" nil nil t))))
Stefan Monnier's avatar
Stefan Monnier committed
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
    (and cookies (url-http-debug "Found %d Set-Cookie headers" (length cookies)))
    (and cookies2 (url-http-debug "Found %d Set-Cookie2 headers" (length cookies2)))
    (while cookies
      (url-cookie-handle-set-cookie (pop cookies)))
;;;     (while cookies2
;;;       (url-cookie-handle-set-cookie2 (pop cookies)))
    )
  )

(defun url-http-parse-headers ()
 "Parse and handle HTTP specific headers.
Return t if and only if the current buffer is still active and
should be shown to the user."
  ;; The comments after each status code handled are taken from RFC
  ;; 2616 (HTTP/1.1)
  (declare (special url-http-end-of-headers url-http-response-status
454
		    url-http-response-version
Stefan Monnier's avatar
Stefan Monnier committed
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
		    url-http-method url-http-data url-http-process
		    url-callback-function url-callback-arguments))

  (url-http-mark-connection-as-free (url-host url-current-object)
				    (url-port url-current-object)
				    url-http-process)

  (if (or (not (boundp 'url-http-end-of-headers))
	  (not url-http-end-of-headers))
      (error "Trying to parse headers in odd buffer: %s" (buffer-name)))
  (goto-char (point-min))
  (url-http-debug "url-http-parse-headers called in (%s)" (buffer-name))
  (url-http-parse-response)
  (mail-narrow-to-head)
  ;;(narrow-to-region (point-min) url-http-end-of-headers)
470
  (let ((connection (mail-fetch-field "Connection")))
471 472 473 474
    ;; In HTTP 1.0, keep the connection only if there is a
    ;; "Connection: keep-alive" header.
    ;; In HTTP 1.1 (and greater), keep the connection unless there is a
    ;; "Connection: close" header
Juanma Barranquero's avatar
Juanma Barranquero committed
475
    (cond
476 477 478
     ((string= url-http-response-version "1.0")
      (unless (and connection
		   (string= (downcase connection) "keep-alive"))
479
	(delete-process url-http-process)))
480 481 482 483
     (t
      (when (and connection
		 (string= (downcase connection) "close"))
	(delete-process url-http-process)))))
484 485
  (let ((buffer (current-buffer))
	(class nil)
486 487
	(success nil)
	;; other status symbols: jewelry and luxury cars
Juanma Barranquero's avatar
Juanma Barranquero committed
488
	(status-symbol (cadr (assq url-http-response-status url-http-codes)))
489
	;; The filename part of a URL could be in remote file syntax,
490 491 492
	;; see Bug#6717 for an example.  We disable file name
	;; handlers, therefore.
	(file-name-handler-alist nil))
Stefan Monnier's avatar
Stefan Monnier committed
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
    (setq class (/ url-http-response-status 100))
    (url-http-debug "Parsed HTTP headers: class=%d status=%d" class url-http-response-status)
    (url-http-handle-cookies)

    (case class
      ;; Classes of response codes
      ;;
      ;; 5xx = Server Error
      ;; 4xx = Client Error
      ;; 3xx = Redirection
      ;; 2xx = Successful
      ;; 1xx = Informational
      (1				; Information messages
       ;; 100 = Continue with request
       ;; 101 = Switching protocols
       ;; 102 = Processing (Added by DAV)
509
       (url-mark-buffer-as-dead buffer)
Stefan Monnier's avatar
Stefan Monnier committed
510 511 512 513 514 515 516 517 518 519
       (error "HTTP responses in class 1xx not supported (%d)" url-http-response-status))
      (2				; Success
       ;; 200 Ok
       ;; 201 Created
       ;; 202 Accepted
       ;; 203 Non-authoritative information
       ;; 204 No content
       ;; 205 Reset content
       ;; 206 Partial content
       ;; 207 Multi-status (Added by DAV)
520 521
       (case status-symbol
	 ((no-content reset-content)
Stefan Monnier's avatar
Stefan Monnier committed
522
	  ;; No new data, just stay at the same document
523
	  (url-mark-buffer-as-dead buffer)
Stefan Monnier's avatar
Stefan Monnier committed
524 525 526 527 528
	  (setq success t))
	 (otherwise
	  ;; Generic success for all others.  Store in the cache, and
	  ;; mark it as successful.
	  (widen)
529
	  (if (and url-automatic-caching (equal url-http-method "GET"))
530
	      (url-store-in-cache buffer))
Stefan Monnier's avatar
Stefan Monnier committed
531 532 533 534 535 536 537 538 539 540 541
	  (setq success t))))
      (3				; Redirection
       ;; 300 Multiple choices
       ;; 301 Moved permanently
       ;; 302 Found
       ;; 303 See other
       ;; 304 Not modified
       ;; 305 Use proxy
       ;; 307 Temporary redirect
       (let ((redirect-uri (or (mail-fetch-field "Location")
			       (mail-fetch-field "URI"))))
542 543
	 (case status-symbol
	   (multiple-choices	    ; 300
Stefan Monnier's avatar
Stefan Monnier committed
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
	    ;; Quoth the spec (section 10.3.1)
	    ;; -------------------------------
	    ;; The requested resource corresponds to any one of a set of
	    ;; representations, each with its own specific location and
	    ;; agent-driven negotiation information is being provided so
	    ;; that the user can select a preferred representation and
	    ;; redirect its request to that location.
	    ;; [...]
	    ;; If the server has a preferred choice of representation, it
	    ;; SHOULD include the specific URI for that representation in
	    ;; the Location field; user agents MAY use the Location field
	    ;; value for automatic redirection.
	    ;; -------------------------------
	    ;; We do not support agent-driven negotiation, so we just
	    ;; redirect to the preferred URI if one is provided.
	    nil)
560
	   ((moved-permanently found temporary-redirect) ; 301 302 307
Stefan Monnier's avatar
Stefan Monnier committed
561 562 563 564 565 566 567 568 569 570 571 572 573 574
	    ;; If the 301|302 status code is received in response to a
	    ;; request other than GET or HEAD, the user agent MUST NOT
	    ;; automatically redirect the request unless it can be
	    ;; confirmed by the user, since this might change the
	    ;; conditions under which the request was issued.
	    (if (member url-http-method '("HEAD" "GET"))
		;; Automatic redirection is ok
		nil
	      ;; It is just too big of a pain in the ass to get this
	      ;; prompt all the time.  We will just silently lose our
	      ;; data and convert to a GET method.
	      (url-http-debug "Converting `%s' request to `GET' because of REDIRECT(%d)"
			      url-http-method url-http-response-status)
	      (setq url-http-method "GET"
575
		    url-http-data nil)))
576
	   (see-other			; 303
Stefan Monnier's avatar
Stefan Monnier committed
577 578 579 580 581
	    ;; The response to the request can be found under a different
	    ;; URI and SHOULD be retrieved using a GET method on that
	    ;; resource.
	    (setq url-http-method "GET"
		  url-http-data nil))
582
	   (not-modified		; 304
Stefan Monnier's avatar
Stefan Monnier committed
583 584 585 586 587 588
	    ;; The 304 response MUST NOT contain a message-body.
	    (url-http-debug "Extracting document from cache... (%s)"
			    (url-cache-create-filename (url-view-url t)))
	    (url-cache-extract (url-cache-create-filename (url-view-url t)))
	    (setq redirect-uri nil
		  success t))
589
	   (use-proxy			; 305
Stefan Monnier's avatar
Stefan Monnier committed
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
	    ;; The requested resource MUST be accessed through the
	    ;; proxy given by the Location field.  The Location field
	    ;; gives the URI of the proxy.  The recipient is expected
	    ;; to repeat this single request via the proxy.  305
	    ;; responses MUST only be generated by origin servers.
	    (error "Redirection thru a proxy server not supported: %s"
		   redirect-uri))
	   (otherwise
	    ;; Treat everything like '300'
	    nil))
	 (when redirect-uri
	   ;; Clean off any whitespace and/or <...> cruft.
	   (if (string-match "\\([^ \t]+\\)[ \t]" redirect-uri)
	       (setq redirect-uri (match-string 1 redirect-uri)))
	   (if (string-match "^<\\(.*\\)>$" redirect-uri)
	       (setq redirect-uri (match-string 1 redirect-uri)))

	   ;; Some stupid sites (like sourceforge) send a
	   ;; non-fully-qualified URL (ie: /), which royally confuses
	   ;; the URL library.
	   (if (not (string-match url-nonrelative-link redirect-uri))
Stefan Monnier's avatar
Stefan Monnier committed
611 612 613 614 615
               ;; Be careful to use the real target URL, otherwise we may
               ;; compute the redirection relative to the URL of the proxy.
	       (setq redirect-uri
		     (url-expand-file-name redirect-uri url-http-target-url)))
           (let ((url-request-method url-http-method)
Stefan Monnier's avatar
Stefan Monnier committed
616 617
		 (url-request-data url-http-data)
		 (url-request-extra-headers url-http-extra-headers))
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
	     ;; Check existing number of redirects
	     (if (or (< url-max-redirections 0)
		     (and (> url-max-redirections 0)
			  (let ((events (car url-callback-arguments))
				(old-redirects 0))
			    (while events
			      (if (eq (car events) :redirect)
				  (setq old-redirects (1+ old-redirects)))
			      (and (setq events (cdr events))
				   (setq events (cdr events))))
			    (< old-redirects url-max-redirections))))
		 ;; url-max-redirections hasn't been reached, so go
		 ;; ahead and redirect.
		 (progn
		   ;; Remember that the request was redirected.
		   (setf (car url-callback-arguments)
			 (nconc (list :redirect redirect-uri)
				(car url-callback-arguments)))
		   ;; Put in the current buffer a forwarding pointer to the new
		   ;; destination buffer.
		   ;; FIXME: This is a hack to fix url-retrieve-synchronously
		   ;; without changing the API.  Instead url-retrieve should
		   ;; either simply not return the "destination" buffer, or it
		   ;; should take an optional `dest-buf' argument.
		   (set (make-local-variable 'url-redirect-buffer)
			(url-retrieve-internal
			 redirect-uri url-callback-function
645 646
			 url-callback-arguments
			 (url-silent url-current-object)))
647
		   (url-mark-buffer-as-dead buffer))
648 649 650 651 652 653 654 655
	       ;; We hit url-max-redirections, so issue an error and
	       ;; stop redirecting.
	       (url-http-debug "Maximum redirections reached")
	       (setf (car url-callback-arguments)
		     (nconc (list :error (list 'error 'http-redirect-limit
					       redirect-uri))
			    (car url-callback-arguments)))
	       (setq success t))))))
Stefan Monnier's avatar
Stefan Monnier committed
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
      (4				; Client error
       ;; 400 Bad Request
       ;; 401 Unauthorized
       ;; 402 Payment required
       ;; 403 Forbidden
       ;; 404 Not found
       ;; 405 Method not allowed
       ;; 406 Not acceptable
       ;; 407 Proxy authentication required
       ;; 408 Request time-out
       ;; 409 Conflict
       ;; 410 Gone
       ;; 411 Length required
       ;; 412 Precondition failed
       ;; 413 Request entity too large
       ;; 414 Request-URI too large
       ;; 415 Unsupported media type
       ;; 416 Requested range not satisfiable
       ;; 417 Expectation failed
       ;; 422 Unprocessable Entity (Added by DAV)
       ;; 423 Locked
       ;; 424 Failed Dependency
678 679
       (case status-symbol
	 (unauthorized			; 401
Stefan Monnier's avatar
Stefan Monnier committed
680 681 682 683 684 685
	  ;; The request requires user authentication.  The response
	  ;; MUST include a WWW-Authenticate header field containing a
	  ;; challenge applicable to the requested resource.  The
	  ;; client MAY repeat the request with a suitable
	  ;; Authorization header field.
	  (url-http-handle-authentication nil))
686
	 (payment-required              ; 402
Stefan Monnier's avatar
Stefan Monnier committed
687
	  ;; This code is reserved for future use
688
	  (url-mark-buffer-as-dead buffer)
Stefan Monnier's avatar
Stefan Monnier committed
689
	  (error "Somebody wants you to give them money"))
690
	 (forbidden			; 403
Stefan Monnier's avatar
Stefan Monnier committed
691 692 693 694
	  ;; The server understood the request, but is refusing to
	  ;; fulfill it.  Authorization will not help and the request
	  ;; SHOULD NOT be repeated.
	  (setq success t))
695
	 (not-found			; 404
Stefan Monnier's avatar
Stefan Monnier committed
696 697
	  ;; Not found
	  (setq success t))
698
	 (method-not-allowed		; 405
Stefan Monnier's avatar
Stefan Monnier committed
699 700 701 702 703
	  ;; The method specified in the Request-Line is not allowed
	  ;; for the resource identified by the Request-URI.  The
	  ;; response MUST include an Allow header containing a list of
	  ;; valid methods for the requested resource.
	  (setq success t))
704
	 (not-acceptable		; 406
Stefan Monnier's avatar
Stefan Monnier committed
705 706 707 708 709
	  ;; The resource identified by the request is only capable of
	  ;; generating response entities which have content
	  ;; characteristics nota cceptable according to the accept
	  ;; headers sent in the request.
	  (setq success t))
710
	 (proxy-authentication-required ; 407
Stefan Monnier's avatar
Stefan Monnier committed
711 712 713 714 715 716
	  ;; This code is similar to 401 (Unauthorized), but indicates
	  ;; that the client must first authenticate itself with the
	  ;; proxy.  The proxy MUST return a Proxy-Authenticate header
	  ;; field containing a challenge applicable to the proxy for
	  ;; the requested resource.
	  (url-http-handle-authentication t))
717
	 (request-timeout		; 408
Stefan Monnier's avatar
Stefan Monnier committed
718 719 720 721
	  ;; The client did not produce a request within the time that
	  ;; the server was prepared to wait.  The client MAY repeat
	  ;; the request without modifications at any later time.
	  (setq success t))
722
	 (conflict			; 409
Stefan Monnier's avatar
Stefan Monnier committed
723 724 725 726 727 728 729 730
	  ;; The request could not be completed due to a conflict with
	  ;; the current state of the resource.  This code is only
	  ;; allowed in situations where it is expected that the user
	  ;; mioght be able to resolve the conflict and resubmit the
	  ;; request.  The response body SHOULD include enough
	  ;; information for the user to recognize the source of the
	  ;; conflict.
	  (setq success t))
731
	 (gone                          ; 410
Stefan Monnier's avatar
Stefan Monnier committed
732 733 734
	  ;; The requested resource is no longer available at the
	  ;; server and no forwarding address is known.
	  (setq success t))
735
	 (length-required		; 411
Stefan Monnier's avatar
Stefan Monnier committed
736 737 738 739 740 741 742 743 744
	  ;; The server refuses to accept the request without a defined
	  ;; Content-Length.  The client MAY repeat the request if it
	  ;; adds a valid Content-Length header field containing the
	  ;; length of the message-body in the request message.
	  ;;
	  ;; NOTE - this will never happen because
	  ;; `url-http-create-request' automatically calculates the
	  ;; content-length.
	  (setq success t))
745
	 (precondition-failed		; 412
Stefan Monnier's avatar
Stefan Monnier committed
746 747 748 749
	  ;; The precondition given in one or more of the
	  ;; request-header fields evaluated to false when it was
	  ;; tested on the server.
	  (setq success t))
750
	 ((request-entity-too-large request-uri-too-large) ; 413 414
Stefan Monnier's avatar
Stefan Monnier committed
751 752 753 754
	  ;; The server is refusing to process a request because the
	  ;; request entity|URI is larger than the server is willing or
	  ;; able to process.
	  (setq success t))
755
	 (unsupported-media-type	; 415
Stefan Monnier's avatar
Stefan Monnier committed
756 757 758 759
	  ;; The server is refusing to service the request because the
	  ;; entity of the request is in a format not supported by the
	  ;; requested resource for the requested method.
	  (setq success t))
760
	 (requested-range-not-satisfiable ; 416
Stefan Monnier's avatar
Stefan Monnier committed
761 762 763 764 765 766
	  ;; A server SHOULD return a response with this status code if
	  ;; a request included a Range request-header field, and none
	  ;; of the range-specifier values in this field overlap the
	  ;; current extent of the selected resource, and the request
	  ;; did not include an If-Range request-header field.
	  (setq success t))
767
	 (expectation-failed		; 417
Stefan Monnier's avatar
Stefan Monnier committed
768 769 770 771 772 773 774 775 776
	  ;; The expectation given in an Expect request-header field
	  ;; could not be met by this server, or, if the server is a
	  ;; proxy, the server has unambiguous evidence that the
	  ;; request could not be met by the next-hop server.
	  (setq success t))
	 (otherwise
	  ;; The request could not be understood by the server due to
	  ;; malformed syntax.  The client SHOULD NOT repeat the
	  ;; request without modifications.
777 778 779 780 781 782 783
	  (setq success t)))
       ;; Tell the callback that an error occurred, and what the
       ;; status code was.
       (when success
	 (setf (car url-callback-arguments)
	       (nconc (list :error (list 'error 'http url-http-response-status))
		      (car url-callback-arguments)))))
Stefan Monnier's avatar
Stefan Monnier committed
784 785 786 787 788 789 790 791 792 793
      (5
       ;; 500 Internal server error
       ;; 501 Not implemented
       ;; 502 Bad gateway
       ;; 503 Service unavailable
       ;; 504 Gateway time-out
       ;; 505 HTTP version not supported
       ;; 507 Insufficient storage
       (setq success t)
       (case url-http-response-status
794
	 (not-implemented		; 501
Stefan Monnier's avatar
Stefan Monnier committed
795 796 797
	  ;; The server does not support the functionality required to
	  ;; fulfill the request.
	  nil)
798
	 (bad-gateway			; 502
Stefan Monnier's avatar
Stefan Monnier committed
799 800 801 802
	  ;; The server, while acting as a gateway or proxy, received
	  ;; an invalid response from the upstream server it accessed
	  ;; in attempting to fulfill the request.
	  nil)
803
	 (service-unavailable		; 503
Stefan Monnier's avatar
Stefan Monnier committed
804 805 806 807 808 809 810 811
	  ;; The server is currently unable to handle the request due
	  ;; to a temporary overloading or maintenance of the server.
	  ;; The implication is that this is a temporary condition
	  ;; which will be alleviated after some delay.  If known, the
	  ;; length of the delay MAY be indicated in a Retry-After
	  ;; header.  If no Retry-After is given, the client SHOULD
	  ;; handle the response as it would for a 500 response.
	  nil)
812
	 (gateway-timeout		; 504
Stefan Monnier's avatar
Stefan Monnier committed
813 814 815 816 817 818
	  ;; The server, while acting as a gateway or proxy, did not
	  ;; receive a timely response from the upstream server
	  ;; specified by the URI (e.g. HTTP, FTP, LDAP) or some other
	  ;; auxiliary server (e.g. DNS) it needed to access in
	  ;; attempting to complete the request.
	  nil)
819
	 (http-version-not-supported	; 505
Stefan Monnier's avatar
Stefan Monnier committed
820 821 822 823
	  ;; The server does not support, or refuses to support, the
	  ;; HTTP protocol version that was used in the request
	  ;; message.
	  nil)
824
	 (insufficient-storage		; 507 (DAV)
Stefan Monnier's avatar
Stefan Monnier committed
825 826 827 828 829 830 831
	  ;; The method could not be performed on the resource
	  ;; because the server is unable to store the representation
	  ;; needed to successfully complete the request.  This
	  ;; condition is considered to be temporary.  If the request
	  ;; which received this status code was the result of a user
	  ;; action, the request MUST NOT be repeated until it is
	  ;; requested by a separate user action.
832 833 834 835 836 837 838
	  nil))
       ;; Tell the callback that an error occurred, and what the
       ;; status code was.
       (when success
	 (setf (car url-callback-arguments)
	       (nconc (list :error (list 'error 'http url-http-response-status))
		      (car url-callback-arguments)))))
Stefan Monnier's avatar
Stefan Monnier committed
839 840 841 842
      (otherwise
       (error "Unknown class of HTTP response code: %d (%d)"
	      class url-http-response-status)))
    (if (not success)
843
	(url-mark-buffer-as-dead buffer))
Stefan Monnier's avatar
Stefan Monnier committed
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
    (url-http-debug "Finished parsing HTTP headers: %S" success)
    (widen)
    success))

;; Miscellaneous
(defun url-http-activate-callback ()
  "Activate callback specified when this buffer was created."
  (declare (special url-http-process
		    url-callback-function
		    url-callback-arguments))
  (url-http-mark-connection-as-free (url-host url-current-object)
				    (url-port url-current-object)
				    url-http-process)
  (url-http-debug "Activating callback in buffer (%s)" (buffer-name))
  (apply url-callback-function url-callback-arguments))

;; )

;; These unfortunately cannot be macros... please ignore them!
(defun url-http-idle-sentinel (proc why)
Juanma Barranquero's avatar
Juanma Barranquero committed
864
  "Remove (now defunct) process PROC from the list of open connections."
Stefan Monnier's avatar
Stefan Monnier committed
865 866 867 868 869 870 871 872 873 874 875
  (maphash (lambda (key val)
		(if (memq proc val)
		    (puthash key (delq proc val) url-http-open-connections)))
	      url-http-open-connections))

(defun url-http-end-of-document-sentinel (proc why)
  ;; Sentinel used for old HTTP/0.9 or connections we know are going
  ;; to die as the 'end of document' notifier.
  (url-http-debug "url-http-end-of-document-sentinel in buffer (%s)"
		  (process-buffer proc))
  (url-http-idle-sentinel proc why)
876 877 878 879 880 881 882 883
  (when (buffer-name (process-buffer proc))
    (with-current-buffer (process-buffer proc)
      (goto-char (point-min))
      (if (not (looking-at "HTTP/"))
	  ;; HTTP/0.9 just gets passed back no matter what
	  (url-http-activate-callback)
	(if (url-http-parse-headers)
	    (url-http-activate-callback))))))
Stefan Monnier's avatar
Stefan Monnier committed
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923

(defun url-http-simple-after-change-function (st nd length)
  ;; Function used when we do NOT know how long the document is going to be
  ;; Just _very_ simple 'downloaded %d' type of info.
  (declare (special url-http-end-of-headers))
  (url-lazy-message "Reading %s..." (url-pretty-length nd)))

(defun url-http-content-length-after-change-function (st nd length)
  "Function used when we DO know how long the document is going to be.
More sophisticated percentage downloaded, etc.
Also does minimal parsing of HTTP headers and will actually cause
the callback to be triggered."
  (declare (special url-current-object
		    url-http-end-of-headers
		    url-http-content-length
		    url-http-content-type
		    url-http-process))
  (if url-http-content-type
      (url-display-percentage
       "Reading [%s]... %s of %s (%d%%)"
       (url-percentage (- nd url-http-end-of-headers)
		       url-http-content-length)
       url-http-content-type
       (url-pretty-length (- nd url-http-end-of-headers))
       (url-pretty-length url-http-content-length)
       (url-percentage (- nd url-http-end-of-headers)
		       url-http-content-length))
    (url-display-percentage
     "Reading... %s of %s (%d%%)"
     (url-percentage (- nd url-http-end-of-headers)
		     url-http-content-length)
     (url-pretty-length (- nd url-http-end-of-headers))
     (url-pretty-length url-http-content-length)
     (url-percentage (- nd url-http-end-of-headers)
		     url-http-content-length)))

  (if (> (- nd url-http-end-of-headers) url-http-content-length)
      (progn
	;; Found the end of the document!  Wheee!
	(url-display-percentage nil nil)
924
	(url-lazy-message "Reading... done.")
Stefan Monnier's avatar
Stefan Monnier committed
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
	(if (url-http-parse-headers)
	    (url-http-activate-callback)))))

(defun url-http-chunked-encoding-after-change-function (st nd length)
  "Function used when dealing with 'chunked' encoding.
Cannot give a sophisticated percentage, but we need a different
function to look for the special 0-length chunk that signifies
the end of the document."
  (declare (special url-current-object
		    url-http-end-of-headers
		    url-http-content-type
		    url-http-chunked-length
		    url-http-chunked-counter
		    url-http-process url-http-chunked-start))
  (save-excursion
    (goto-char st)
    (let ((read-next-chunk t)
	  (case-fold-search t)
	  (regexp nil)
	  (no-initial-crlf nil))
      ;; We need to loop thru looking for more chunks even within
      ;; one after-change-function call.
      (while read-next-chunk
	(setq no-initial-crlf (= 0 url-http-chunked-counter))
	(if url-http-content-type
	    (url-display-percentage nil
	     "Reading [%s]... chunk #%d"
	     url-http-content-type url-http-chunked-counter)
	  (url-display-percentage nil
	   "Reading... chunk #%d"
	   url-http-chunked-counter))
	(url-http-debug "Reading chunk %d (%d %d %d)"
			url-http-chunked-counter st nd length)
	(setq regexp (if no-initial-crlf
			 "\\([0-9a-z]+\\).*\r?\n"
		       "\r?\n\\([0-9a-z]+\\).*\r?\n"))

	(if url-http-chunked-start
	    ;; We know how long the chunk is supposed to be, skip over
	    ;; leading crap if possible.
	    (if (> nd (+ url-http-chunked-start url-http-chunked-length))
		(progn
		  (url-http-debug "Got to the end of chunk #%d!"
				  url-http-chunked-counter)
		  (goto-char (+ url-http-chunked-start
				url-http-chunked-length)))
	      (url-http-debug "Still need %d bytes to hit end of chunk"
			      (- (+ url-http-chunked-start
				    url-http-chunked-length)
				 nd))
	      (setq read-next-chunk nil)))
	(if (not read-next-chunk)
	    (url-http-debug "Still spinning for next chunk...")
	  (if no-initial-crlf (skip-chars-forward "\r\n"))
	  (if (not (looking-at regexp))
	      (progn
	   ;; Must not have received the entirety of the chunk header,
		;; need to spin some more.
		(url-http-debug "Did not see start of chunk @ %d!" (point))
		(setq read-next-chunk nil))
 	    (add-text-properties (match-beginning 0) (match-end 0)
				 (list 'start-open t
				       'end-open t
				       'chunked-encoding t
Eli Zaretskii's avatar
Eli Zaretskii committed
989
				       'face 'cursor
Stefan Monnier's avatar
Stefan Monnier committed
990
				       'invisible t))
991 992 993 994
	    (setq url-http-chunked-length (string-to-number (buffer-substring
                                                             (match-beginning 1)
                                                             (match-end 1))
                                                            16)
Stefan Monnier's avatar
Stefan Monnier committed
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
		  url-http-chunked-counter (1+ url-http-chunked-counter)
		  url-http-chunked-start (set-marker
					  (or url-http-chunked-start
					      (make-marker))
					  (match-end 0)))
;	    (if (not url-http-debug)
		(delete-region (match-beginning 0) (match-end 0));)
	    (url-http-debug "Saw start of chunk %d (length=%d, start=%d"
			    url-http-chunked-counter url-http-chunked-length
			    (marker-position url-http-chunked-start))
	    (if (= 0 url-http-chunked-length)
		(progn
		  ;; Found the end of the document!  Wheee!
		  (url-http-debug "Saw end of stream chunk!")
		  (setq read-next-chunk nil)
		  (url-display-percentage nil nil)
1011 1012 1013 1014 1015
		  ;; Every chunk, even the last 0-length one, is
		  ;; terminated by CRLF.  Skip it.
		  (when (looking-at "\r?\n")
		    (url-http-debug "Removing terminator of last chunk")
		    (delete-region (match-beginning 0) (match-end 0)))
Stefan Monnier's avatar
Stefan Monnier committed
1016
		  (if (re-search-forward "^\r*$" nil t)
1017
		      (url-http-debug "Saw end of trailers..."))
Stefan Monnier's avatar
Stefan Monnier committed
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
		  (if (url-http-parse-headers)
		      (url-http-activate-callback))))))))))

(defun url-http-wait-for-headers-change-function (st nd length)
  ;; This will wait for the headers to arrive and then splice in the
  ;; next appropriate after-change-function, etc.
  (declare (special url-current-object
		    url-http-end-of-headers
		    url-http-content-type
		    url-http-content-length
		    url-http-transfer-encoding
		    url-callback-function
		    url-callback-arguments
		    url-http-process
		    url-http-method
		    url-http-after-change-function
		    url-http-response-status))
  (url-http-debug "url-http-wait-for-headers-change-function (%s)"
		  (buffer-name))
1037 1038 1039 1040 1041
  (let ((end-of-headers nil)
	(old-http nil)
	(process-buffer (current-buffer))
	(content-length nil))
    (when (not (bobp))
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
      (goto-char (point-min))
      (if (and (looking-at ".*\n")	; have one line at least
	       (not (looking-at "^HTTP/[1-9]\\.[0-9]")))
	  ;; Not HTTP/x.y data, must be 0.9
	  ;; God, I wish this could die.
	  (setq end-of-headers t
		url-http-end-of-headers 0
		old-http t)
	(when (re-search-forward "^\r*$" nil t)
	  ;; Saw the end of the headers
	  (url-http-debug "Saw end of headers... (%s)" (buffer-name))
	  (setq url-http-end-of-headers (set-marker (make-marker)
						    (point))
		end-of-headers t)
	  (url-http-clean-headers)))
Stefan Monnier's avatar
Stefan Monnier committed
1057

1058
      (if (not end-of-headers)
1059 1060 1061
	  ;; Haven't seen the end of the headers yet, need to wait
	  ;; for more data to arrive.
	  nil
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
	(unless old-http
	  (url-http-parse-response)
	  (mail-narrow-to-head)
	  (setq url-http-transfer-encoding (mail-fetch-field
					    "transfer-encoding")
		url-http-content-type (mail-fetch-field "content-type"))
	  (if (mail-fetch-field "content-length")
	      (setq url-http-content-length
		    (string-to-number (mail-fetch-field "content-length"))))
	  (widen))
1072 1073 1074
	(when url-http-transfer-encoding
	  (setq url-http-transfer-encoding
		(downcase url-http-transfer-encoding)))
Stefan Monnier's avatar
Stefan Monnier committed
1075

1076
	(cond
1077 1078 1079 1080
	 ((null url-http-response-status)
	  ;; We got back a headerless malformed response from the
	  ;; server.
	  (url-http-activate-callback))
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
	 ((or (= url-http-response-status 204)
	      (= url-http-response-status 205))
	  (url-http-debug "%d response must have headers only (%s)."
			  url-http-response-status (buffer-name))
	  (when (url-http-parse-headers)
	    (url-http-activate-callback)))
	 ((string= "HEAD" url-http-method)
	  ;; A HEAD request is _ALWAYS_ terminated by the header
	  ;; information, regardless of any entity headers,
	  ;; according to section 4.4 of the HTTP/1.1 draft.
	  (url-http-debug "HEAD request must have headers only (%s)."
			  (buffer-name))
	  (when (url-http-parse-headers)
	    (url-http-activate-callback)))
	 ((string= "CONNECT" url-http-method)
	  ;; A CONNECT request is finished, but we cannot stick this
	  ;; back on the free connectin list
	  (url-http-debug "CONNECT request must have headers only.")
	  (when (url-http-parse-headers)
	    (url-http-activate-callback)))
	 ((equal url-http-response-status 304)
	  ;; Only allowed to have a header section.  We have to handle
	  ;; this here instead of in url-http-parse-headers because if
	  ;; you have a cached copy of something without a known
	  ;; content-length, and try to retrieve it from the cache, we'd
	  ;; fall into the 'being dumb' section and wait for the
	  ;; connection to terminate, which means we'd wait for 10
	  ;; seconds for the keep-alives to time out on some servers.
	  (when (url-http-parse-headers)
	    (url-http-activate-callback)))
	 (old-http
	  ;; HTTP/0.9 always signaled end-of-connection by closing the
	  ;; connection.
	  (url-http-debug
	   "Saw HTTP/0.9 response, connection closed means end of document.")
	  (setq url-http-after-change-function
		'url-http-simple-after-change-function))
	 ((equal url-http-transfer-encoding "chunked")
	  (url-http-debug "Saw chunked encoding.")
	  (setq url-http-after-change-function
		'url-http-chunked-encoding-after-change-function)
	  (when (> nd url-http-end-of-headers)
Stefan Monnier's avatar
Stefan Monnier committed
1123
	    (url-http-debug
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
	     "Calling initial chunked-encoding for extra data at end of headers")
	    (url-http-chunked-encoding-after-change-function
	     (marker-position url-http-end-of-headers) nd
	     (- nd url-http-end-of-headers))))
	 ((integerp url-http-content-length)
	  (url-http-debug
	   "Got a content-length, being smart about document end.")
	  (setq url-http-after-change-function
		'url-http-content-length-after-change-function)
	  (cond
	   ((= 0 url-http-content-length)
	    ;; We got a NULL body!  Activate the callback
	    ;; immediately!
Stefan Monnier's avatar
Stefan Monnier committed
1137
	    (url-http-debug
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
	     "Got 0-length content-length, activating callback immediately.")
	    (when (url-http-parse-headers)
	      (url-http-activate-callback)))
	   ((> nd url-http-end-of-headers)
	    ;; Have some leftover data
	    (url-http-debug "Calling initial content-length for extra data at end of headers")
	    (url-http-content-length-after-change-function
	     (marker-position url-http-end-of-headers)
	     nd
	     (- nd url-http-end-of-headers)))
Stefan Monnier's avatar
Stefan Monnier committed
1148
	   (t
1149 1150 1151 1152 1153
	    nil)))
	 (t
	  (url-http-debug "No content-length, being dumb.")
	  (setq url-http-after-change-function
		'url-http-simple-after-change-function)))))
Stefan Monnier's avatar
Stefan Monnier committed
1154 1155
    ;; We are still at the beginning of the buffer... must just be
    ;; waiting for a response.
1156 1157 1158
    (url-http-debug "Spinning waiting for headers...")
    (when (eq process-buffer (current-buffer))
      (goto-char (point-max)))))
Stefan Monnier's avatar
Stefan Monnier committed
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174

;;;###autoload
(defun url-http (url callback cbargs)
  "Retrieve URL via HTTP asynchronously.
URL must be a parsed URL.  See `url-generic-parse-url' for details.
When retrieval is completed, the function CALLBACK is executed with
CBARGS as the arguments."
  (check-type url vector "Need a pre-parsed URL.")
  (declare (special url-current-object
		    url-http-end-of-headers
		    url-http-content-type
		    url-http-content-length
		    url-http-transfer-encoding
		    url-http-after-change-function
		    url-callback-function
		    url-callback-arguments
1175
		    url-show-status
Stefan Monnier's avatar
Stefan Monnier committed
1176 1177 1178 1179 1180 1181
		    url-http-method
		    url-http-extra-headers
		    url-http-data
		    url-http-chunked-length
		    url-http-chunked-start
		    url-http-chunked-counter
1182
		    url-http-process))
1183 1184 1185 1186
  (let* ((host (url-host (or url-using-proxy url)))
	 (port (url-port (or url-using-proxy url)))
	 (connection (url-http-find-free-connection host port))
	 (buffer (generate-new-buffer (format " *http %s:%d*" host port))))
Stefan Monnier's avatar
Stefan Monnier committed
1187 1188 1189 1190 1191
    (if (not connection)
	;; Failed to open the connection for some reason
	(progn
	  (kill-buffer buffer)
	  (setq buffer nil)
1192
	  (error "Could not create connection to %s:%d" host port))
Stefan Monnier's avatar
Stefan Monnier committed
1193
      (with-current-buffer buffer
Stefan Monnier's avatar
Stefan Monnier committed
1194 1195 1196 1197 1198 1199 1200 1201 1202
	(mm-disable-multibyte)
	(setq url-current-object url
	      mode-line-format "%b [%s]")

	(dolist (var '(url-http-end-of-headers
		       url-http-content-type
		       url-http-content-length
		       url-http-transfer-encoding
		       url-http-after-change-function
1203
		       url-http-response-version
Stefan Monnier's avatar
Stefan Monnier committed
1204 1205 1206 1207 1208 1209
		       url-http-response-status
		       url-http-chunked-length
		       url-http-chunked-counter
		       url-http-chunked-start
		       url-callback-function
		       url-callback-arguments
1210
		       url-show-status
Stefan Monnier's avatar
Stefan Monnier committed
1211 1212 1213
		       url-http-process
		       url-http-method
		       url-http-extra-headers
1214
		       url-http-data
1215
		       url-http-target-url
1216
		       url-http-connection-opened
1217
		       url-http-proxy))
Stefan Monnier's avatar
Stefan Monnier committed
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
	  (set (make-local-variable var) nil))

	(setq url-http-method (or url-request-method "GET")
	      url-http-extra-headers url-request-extra-headers
	      url-http-data url-request-data
	      url-http-process connection
	      url-http-chunked-length nil
	      url-http-chunked-start nil
	      url-http-chunked-counter 0
	      url-callback-function callback
	      url-callback-arguments cbargs
1229
	      url-http-after-change-function 'url-http-wait-for-headers-change-function
1230
	      url-http-target-url url-current-object
1231
	      url-http-connection-opened nil
1232
	      url-http-proxy url-using-proxy)
Stefan Monnier's avatar
Stefan Monnier committed
1233 1234 1235

	(set-process-buffer connection buffer)
	(set-process-filter connection 'url-http-generic-filter)
1236 1237 1238 1239 1240 1241 1242
	(let ((status (process-status connection)))
	  (cond
	   ((eq status 'connect)
	    ;; Asynchronous connection
	    (set-process-sentinel connection 'url-http-async-sentinel))
	   ((eq status 'failed)
	    ;; Asynchronous connection failed
1243
	    (error "Could not create connection to %s:%d" host port))
1244 1245
	   (t
	    (set-process-sentinel connection 'url-http-end-of-document-sentinel)
1246
	    (process-send-string connection (url-http-create-request)))))))
Stefan Monnier's avatar
Stefan Monnier committed
1247 1248
    buffer))

1249 1250 1251 1252
(defun url-http-async-sentinel (proc why)
  (declare (special url-callback-arguments))
  ;; We are performing an asynchronous connection, and a status change
  ;; has occurred.
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
  (when (buffer-name (process-buffer proc))
    (with-current-buffer (process-buffer proc)
      (cond
       (url-http-connection-opened
	(url-http-end-of-document-sentinel proc why))
       ((string= (substring why 0 4) "open")
	(setq url-http-connection-opened t)
	(process-send-string proc (url-http-create-request)))
       (t
	(setf (car url-callback-arguments)
	      (nconc (list :error (list 'error 'connection-failed why
					:host (url-host (or url-http-proxy url-current-object))
					:service (url-port (or url-http-proxy url-current-object))))