lisp/url/url-cookie.el

   1 ;;; url-cookie.el --- Netscape Cookie support
   2
   3 ;; Copyright (C) 1996, 1997, 1998, 1999, 2004,
   4 ;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6 ;; Keywords: comm, data, processes, hypermedia
   7
   8 ;; This file is part of GNU Emacs.
   9 ;;
  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 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; 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/>.
  22
  23 ;;; Commentary:
  24
  25 ;;; Code:
  26
  27 (require 'timezone)
  28 (require 'url-util)
  29 (require 'url-parse)
  30 (eval-when-compile (require 'cl))
  31
  32 ;; See http://home.netscape.com/newsref/std/cookie_spec.html for the
  33 ;; 'open standard' defining this crap.
  34
  35 (defgroup url-cookie nil
  36   "URL cookies."
  37   :prefix "url-"
  38   :prefix "url-cookie-"
  39   :group 'url)
  40
  41 ;; A cookie is stored internally as a vector of 7 slots
  42 ;; [ cookie NAME VALUE EXPIRES LOCALPART DOMAIN SECURE ]
  43
  44 (defstruct (url-cookie
  45             (:constructor url-cookie-create)
  46             (:copier nil)
  47             ;; For compatibility with a previous version which did not use
  48             ;; defstruct, and also in order to make sure that the printed
  49             ;; representation does not depend on CL internals, we use an
  50             ;; explicitly managed tag.
  51             (:type vector))
  52   (tag 'cookie :read-only t)
  53   name value expires localpart domain secure)
  54
  55 (defvar url-cookie-storage nil         "Where cookies are stored.")
  56 (defvar url-cookie-secure-storage nil  "Where secure cookies are stored.")
  57 (defcustom url-cookie-file nil
  58   "File where cookies are stored on disk."
  59   :type '(choice (const :tag "Default" :value nil) file)
  60   :group 'url-file
  61   :group 'url-cookie)
  62
  63 (defcustom url-cookie-confirmation nil
  64   "If non-nil, confirmation by the user is required to accept HTTP cookies."
  65   :type 'boolean
  66   :group 'url-cookie)
  67
  68 (defcustom url-cookie-multiple-line nil
  69   "If nil, HTTP requests put all cookies for the server on one line.
  70 Some web servers, such as http://www.hotmail.com/, only accept cookies
  71 when they are on one line.  This is broken behavior, but just try
  72 telling Microsoft that."
  73   :type 'boolean
  74   :group 'url-cookie)
  75
  76 (defvar url-cookies-changed-since-last-save nil
  77   "Whether the cookies list has changed since the last save operation.")
  78
  79 (defun url-cookie-parse-file (&optional fname)
  80   (setq fname (or fname url-cookie-file))
  81   (condition-case ()
  82       (load fname nil t)
  83     (error
  84      ;; It's completely normal for the cookies file not to exist yet.
  85      ;; (message "Could not load cookie file %s" fname)
  86      )))
  87
  88 (declare-function url-cookie-p "url-cookie" t t) ; defstruct
  89
  90 (defun url-cookie-clean-up (&optional secure)
  91   (let* (
  92          (var (if secure 'url-cookie-secure-storage 'url-cookie-storage))
  93          (val (symbol-value var))
  94          (cur nil)
  95          (new nil)
  96          (cookies nil)
  97          (cur-cookie nil)
  98          (new-cookies nil)
  99          )
 100     (while val
 101       (setq cur (car val)
 102             val (cdr val)
 103             new-cookies nil
 104             cookies (cdr cur))
 105       (while cookies
 106         (setq cur-cookie (car cookies)
 107               cookies (cdr cookies))
 108         (if (or (not (url-cookie-p cur-cookie))
 109                 (url-cookie-expired-p cur-cookie)
 110                 (null (url-cookie-expires cur-cookie)))
 111             nil
 112           (setq new-cookies (cons cur-cookie new-cookies))))
 113       (if (not new-cookies)
 114           nil
 115         (setcdr cur new-cookies)
 116         (setq new (cons cur new))))
 117     (set var new)))
 118
 119 (defun url-cookie-write-file (&optional fname)
 120   (when url-cookies-changed-since-last-save
 121     (or fname (setq fname (expand-file-name url-cookie-file)))
 122     (if (condition-case nil
 123             (progn
 124               (url-make-private-file fname)
 125               nil)
 126           (error t))
 127         (message "Error accessing cookie file `%s'" fname)
 128     (url-cookie-clean-up)
 129     (url-cookie-clean-up t)
 130     (with-temp-buffer
 131       (insert ";; Emacs-W3 HTTP cookies file\n"
 132               ";; Automatically generated file!!! DO NOT EDIT!!!\n\n"
 133               "(setq url-cookie-storage\n '")
 134       (pp url-cookie-storage (current-buffer))
 135       (insert ")\n(setq url-cookie-secure-storage\n '")
 136       (pp url-cookie-secure-storage (current-buffer))
 137       (insert ")\n")
 138       (insert "\f\n;; Local Variables:\n"
 139               ";; version-control: never\n"
 140               ";; no-byte-compile: t\n"
 141               ";; End:\n")
 142       (set (make-local-variable 'version-control) 'never)
 143       (write-file fname))
 144     (setq url-cookies-changed-since-last-save nil))))
 145
 146 (defun url-cookie-store (name value &optional expires domain localpart secure)
 147   "Store a netscape-style cookie."
 148   (let* ((storage (if secure url-cookie-secure-storage url-cookie-storage))
 149          (tmp storage)
 150          (cur nil)
 151          (found-domain nil))
 152
 153     ;; First, look for a matching domain
 154     (setq found-domain (assoc domain storage))
 155
 156     (if found-domain
 157         ;; Need to either stick the new cookie in existing domain storage
 158         ;; or possibly replace an existing cookie if the names match.
 159         (progn
 160           (setq storage (cdr found-domain)
 161                 tmp nil)
 162           (while storage
 163             (setq cur (car storage)
 164                   storage (cdr storage))
 165             (if (and (equal localpart (url-cookie-localpart cur))
 166                      (equal name (url-cookie-name cur)))
 167                 (progn
 168                   (setf (url-cookie-expires cur) expires)
 169                   (setf (url-cookie-value cur) value)
 170                   (setq tmp t))))
 171           (if (not tmp)
 172               ;; New cookie
 173               (setcdr found-domain (cons
 174                                     (url-cookie-create :name name
 175                                                        :value value
 176                                                        :expires expires
 177                                                        :domain domain
 178                                                        :localpart localpart
 179                                                        :secure secure)
 180                                     (cdr found-domain)))))
 181       ;; Need to add a new top-level domain
 182       (setq tmp (url-cookie-create :name name
 183                                    :value value
 184                                    :expires expires
 185                                    :domain domain
 186                                    :localpart localpart
 187                                    :secure secure))
 188       (cond
 189        (storage
 190         (setcdr storage (cons (list domain tmp) (cdr storage))))
 191        (secure
 192         (setq url-cookie-secure-storage (list (list domain tmp))))
 193        (t
 194         (setq url-cookie-storage (list (list domain tmp))))))))
 195
 196 (defun url-cookie-expired-p (cookie)
 197   (let* (
 198          (exp (url-cookie-expires cookie))
 199          (cur-date (and exp (timezone-parse-date (current-time-string))))
 200          (exp-date (and exp (timezone-parse-date exp)))
 201          (cur-greg (and cur-date (timezone-absolute-from-gregorian
 202                                   (string-to-number (aref cur-date 1))
 203                                   (string-to-number (aref cur-date 2))
 204                                   (string-to-number (aref cur-date 0)))))
 205          (exp-greg (and exp (timezone-absolute-from-gregorian
 206                              (string-to-number (aref exp-date 1))
 207                              (string-to-number (aref exp-date 2))
 208                              (string-to-number (aref exp-date 0)))))
 209          (diff-in-days (and exp (- cur-greg exp-greg)))
 210          )
 211     (cond
 212      ((not exp) nil)                    ; No expiry == expires at browser quit
 213      ((< diff-in-days 0) nil)           ; Expires sometime after today
 214      ((> diff-in-days 0) t)             ; Expired before today
 215      (t                                 ; Expires sometime today, check times
 216       (let* ((cur-time (timezone-parse-time (aref cur-date 3)))
 217              (exp-time (timezone-parse-time (aref exp-date 3)))
 218              (cur-norm (+ (* 360 (string-to-number (aref cur-time 2)))
 219                           (*  60 (string-to-number (aref cur-time 1)))
 220                           (*   1 (string-to-number (aref cur-time 0)))))
 221              (exp-norm (+ (* 360 (string-to-number (aref exp-time 2)))
 222                           (*  60 (string-to-number (aref exp-time 1)))
 223                           (*   1 (string-to-number (aref exp-time 0))))))
 224         (> (- cur-norm exp-norm) 1))))))
 225
 226 (defun url-cookie-retrieve (host localpart &optional secure)
 227   "Retrieve all the netscape-style cookies for a specified HOST and LOCALPART."
 228   (let ((storage (if secure
 229                      (append url-cookie-secure-storage url-cookie-storage)
 230                    url-cookie-storage))
 231         (case-fold-search t)
 232         (cookies nil)
 233         (cur nil)
 234         (retval nil)
 235         (localpart-regexp nil))
 236     (while storage
 237       (setq cur (car storage)
 238             storage (cdr storage)
 239             cookies (cdr cur))
 240       (if (and (car cur)
 241                (string-match
 242                 (concat "^.*"
 243                         (regexp-quote
 244                          ;; Remove the dot from wildcard domains
 245                          ;; before matching.
 246                          (if (eq ?. (aref (car cur) 0))
 247                              (substring (car cur) 1)
 248                            (car cur)))
 249                         "$") host))
 250           ;; The domains match - a possible hit!
 251           (while cookies
 252             (setq cur (car cookies)
 253                   cookies (cdr cookies)
 254                   localpart-regexp (concat "^" (regexp-quote
 255                                                 (url-cookie-localpart cur))))
 256             (if (and (string-match localpart-regexp localpart)
 257                      (not (url-cookie-expired-p cur)))
 258                 (setq retval (cons cur retval))))))
 259     retval))
 260
 261 (defun url-cookie-generate-header-lines (host localpart secure)
 262   (let* ((cookies (url-cookie-retrieve host localpart secure))
 263          (retval nil)
 264          (cur nil)
 265          (chunk nil))
 266     ;; Have to sort this for sending most specific cookies first
 267     (setq cookies (and cookies
 268                        (sort cookies
 269                              (function
 270                               (lambda (x y)
 271                                 (> (length (url-cookie-localpart x))
 272                                    (length (url-cookie-localpart y))))))))
 273     (while cookies
 274       (setq cur (car cookies)
 275             cookies (cdr cookies)
 276             chunk (format "%s=%s" (url-cookie-name cur) (url-cookie-value cur))
 277             retval (if (and url-cookie-multiple-line
 278                             (< 80 (+ (length retval) (length chunk) 4)))
 279                        (concat retval "\r\nCookie: " chunk)
 280                      (if retval
 281                          (concat retval "; " chunk)
 282                        (concat "Cookie: " chunk)))))
 283     (if retval
 284         (concat retval "\r\n")
 285       "")))
 286
 287 (defvar url-cookie-two-dot-domains
 288   (concat "\\.\\("
 289    (mapconcat 'identity (list "com" "edu" "net" "org" "gov" "mil" "int")
 290               "\\|")
 291    "\\)$")
 292   "A regexp of top level domains that only require two matching
 293 '.'s in the domain name in order to set a cookie.")
 294
 295 (defcustom url-cookie-trusted-urls nil
 296   "A list of regular expressions matching URLs to always accept cookies from."
 297   :type '(repeat regexp)
 298   :group 'url-cookie)
 299
 300 (defcustom url-cookie-untrusted-urls nil
 301   "A list of regular expressions matching URLs to never accept cookies from."
 302   :type '(repeat regexp)
 303   :group 'url-cookie)
 304
 305 (defun url-cookie-host-can-set-p (host domain)
 306   (let ((numdots 0)
 307         (last nil)
 308         (case-fold-search t)
 309         (mindots 3))
 310     (while (setq last (string-match "\\." domain last))
 311       (setq numdots (1+ numdots)
 312             last (1+ last)))
 313     (if (string-match url-cookie-two-dot-domains domain)
 314         (setq mindots 2))
 315     (cond
 316      ((string= host domain)             ; Apparently netscape lets you do this
 317       t)
 318      ((>= numdots mindots)              ; We have enough dots in domain name
 319       ;; Need to check and make sure the host is actually _in_ the
 320       ;; domain it wants to set a cookie for though.
 321       (string-match (concat (regexp-quote
 322                              ;; Remove the dot from wildcard domains
 323                              ;; before matching.
 324                              (if (eq ?. (aref domain 0))
 325                                  (substring domain 1)
 326                                domain))
 327                             "$") host))
 328      (t
 329       nil))))
 330
 331 (defun url-cookie-handle-set-cookie (str)
 332   (setq url-cookies-changed-since-last-save t)
 333   (let* ((args (url-parse-args str t))
 334          (case-fold-search t)
 335          (secure (and (assoc-string "secure" args t) t))
 336          (domain (or (cdr-safe (assoc-string "domain" args t))
 337                      (url-host url-current-object)))
 338          (current-url (url-view-url t))
 339          (trusted url-cookie-trusted-urls)
 340          (untrusted url-cookie-untrusted-urls)
 341          (expires (cdr-safe (assoc-string "expires" args t)))
 342          (localpart (or (cdr-safe (assoc-string "path" args t))
 343                         (file-name-directory
 344                          (url-filename url-current-object))))
 345          (rest nil))
 346     (while args
 347       (if (not (member (downcase (car (car args)))
 348                        '("secure" "domain" "expires" "path")))
 349           (setq rest (cons (car args) rest)))
 350       (setq args (cdr args)))
 351
 352     ;; Sometimes we get dates that the timezone package cannot handle very
 353     ;; gracefully - take care of this here, instead of in url-cookie-expired-p
 354     ;; to speed things up.
 355     (if (and expires
 356              (string-match
 357               (concat "^[^,]+, +\\(..\\)-\\(...\\)-\\(..\\) +"
 358                       "\\(..:..:..\\) +\\[*\\([^\]]+\\)\\]*$")
 359               expires))
 360         (setq expires (concat (match-string 1 expires) " "
 361                               (match-string 2 expires) " "
 362                               (match-string 3 expires) " "
 363                               (match-string 4 expires) " ["
 364                               (match-string 5 expires) "]")))
 365
 366     ;; This one is for older Emacs/XEmacs variants that don't
 367     ;; understand this format without tenths of a second in it.
 368     ;; Wednesday, 30-Dec-2037 16:00:00 GMT
 369     ;;       - vs -
 370     ;; Wednesday, 30-Dec-2037 16:00:00.00 GMT
 371     (if (and expires
 372              (string-match
 373               "\\([0-9]+\\)-\\([A-Za-z]+\\)-\\([0-9]+\\)[ \t]+\\([0-9]+:[0-9]+:[0-9]+\\)\\(\\.[0-9]+\\)*[ \t]+\\([-+a-zA-Z0-9]+\\)"
 374               expires))
 375         (setq expires (concat (match-string 1 expires) "-"      ; day
 376                               (match-string 2 expires) "-"      ; month
 377                               (match-string 3 expires) " "      ; year
 378                               (match-string 4 expires) ".00 " ; hour:minutes:seconds
 379                               (match-string 6 expires)))) ":" ; timezone
 380
 381     (while (consp trusted)
 382       (if (string-match (car trusted) current-url)
 383           (setq trusted (- (match-end 0) (match-beginning 0)))
 384         (pop trusted)))
 385     (while (consp untrusted)
 386       (if (string-match (car untrusted) current-url)
 387           (setq untrusted (- (match-end 0) (match-beginning 0)))
 388         (pop untrusted)))
 389     (if (and trusted untrusted)
 390         ;; Choose the more specific match
 391         (if (> trusted untrusted)
 392             (setq untrusted nil)
 393           (setq trusted nil)))
 394     (cond
 395      (untrusted
 396       ;; The site was explicity marked as untrusted by the user
 397       nil)
 398      ((or (eq url-privacy-level 'paranoid)
 399           (and (listp url-privacy-level) (memq 'cookies url-privacy-level)))
 400       ;; user never wants cookies
 401       nil)
 402      ((and url-cookie-confirmation
 403            (not trusted)
 404            (save-window-excursion
 405              (with-output-to-temp-buffer "*Cookie Warning*"
 406                (mapcar
 407                 (function
 408                  (lambda (x)
 409                    (princ (format "%s - %s" (car x) (cdr x))))) rest))
 410              (prog1
 411                  (not (funcall url-confirmation-func
 412                                (format "Allow %s to set these cookies? "
 413                                        (url-host url-current-object))))
 414                (if (get-buffer "*Cookie Warning*")
 415                    (kill-buffer "*Cookie Warning*")))))
 416       ;; user wants to be asked, and declined.
 417       nil)
 418      ((url-cookie-host-can-set-p (url-host url-current-object) domain)
 419       ;; Cookie is accepted by the user, and passes our security checks
 420       (let ((cur nil))
 421         (while rest
 422           (setq cur (pop rest))
 423           (url-cookie-store (car cur) (cdr cur)
 424                             expires domain localpart secure))))
 425      (t
 426       (message "%s tried to set a cookie for domain %s - rejected."
 427                (url-host url-current-object) domain)))))
 428
 429 (defvar url-cookie-timer nil)
 430
 431 (defcustom url-cookie-save-interval 3600
 432   "The number of seconds between automatic saves of cookies.
 433 Default is 1 hour.  Note that if you change this variable outside of
 434 the `customize' interface after `url-do-setup' has been run, you need
 435 to run the `url-cookie-setup-save-timer' function manually."
 436   :set #'(lambda (var val)
 437            (set-default var val)
 438            (if (bound-and-true-p url-setup-done)
 439                (url-cookie-setup-save-timer)))
 440   :type 'integer
 441   :group 'url-cookie)
 442
 443 (defun url-cookie-setup-save-timer ()
 444   "Reset the cookie saver timer."
 445   (interactive)
 446   (ignore-errors (cancel-timer url-cookie-timer))
 447   (setq url-cookie-timer nil)
 448   (if url-cookie-save-interval
 449       (setq url-cookie-timer (run-at-time url-cookie-save-interval
 450                                           url-cookie-save-interval
 451                                           #'url-cookie-write-file))))
 452
 453 (provide 'url-cookie)
 454
 455 ;; arch-tag: 2568751b-6452-4398-aa2d-303edadb54d7
 456 ;;; url-cookie.el ends here