AppPkg/Applications/Python/Python-2.7.2/Lib/Cookie.py

   1 #!/usr/bin/env python
   2 #
   3
   4 ####
   5 # Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>
   6 #
   7 #                All Rights Reserved
   8 #
   9 # Permission to use, copy, modify, and distribute this software
  10 # and its documentation for any purpose and without fee is hereby
  11 # granted, provided that the above copyright notice appear in all
  12 # copies and that both that copyright notice and this permission
  13 # notice appear in supporting documentation, and that the name of
  14 # Timothy O'Malley  not be used in advertising or publicity
  15 # pertaining to distribution of the software without specific, written
  16 # prior permission.
  17 #
  18 # Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  19 # SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  20 # AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
  21 # ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  22 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  23 # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  24 # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  25 # PERFORMANCE OF THIS SOFTWARE.
  26 #
  27 ####
  28 #
  29 # Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp
  30 #   by Timothy O'Malley <timo@alum.mit.edu>
  31 #
  32 #  Cookie.py is a Python module for the handling of HTTP
  33 #  cookies as a Python dictionary.  See RFC 2109 for more
  34 #  information on cookies.
  35 #
  36 #  The original idea to treat Cookies as a dictionary came from
  37 #  Dave Mitchell (davem@magnet.com) in 1995, when he released the
  38 #  first version of nscookie.py.
  39 #
  40 ####
  41
  42 r"""
  43 Here's a sample session to show how to use this module.
  44 At the moment, this is the only documentation.
  45
  46 The Basics
  47 ----------
  48
  49 Importing is easy..
  50
  51    >>> import Cookie
  52
  53 Most of the time you start by creating a cookie.  Cookies come in
  54 three flavors, each with slightly different encoding semantics, but
  55 more on that later.
  56
  57    >>> C = Cookie.SimpleCookie()
  58    >>> C = Cookie.SerialCookie()
  59    >>> C = Cookie.SmartCookie()
  60
  61 [Note: Long-time users of Cookie.py will remember using
  62 Cookie.Cookie() to create an Cookie object.  Although deprecated, it
  63 is still supported by the code.  See the Backward Compatibility notes
  64 for more information.]
  65
  66 Once you've created your Cookie, you can add values just as if it were
  67 a dictionary.
  68
  69    >>> C = Cookie.SmartCookie()
  70    >>> C["fig"] = "newton"
  71    >>> C["sugar"] = "wafer"
  72    >>> C.output()
  73    'Set-Cookie: fig=newton\r\nSet-Cookie: sugar=wafer'
  74
  75 Notice that the printable representation of a Cookie is the
  76 appropriate format for a Set-Cookie: header.  This is the
  77 default behavior.  You can change the header and printed
  78 attributes by using the .output() function
  79
  80    >>> C = Cookie.SmartCookie()
  81    >>> C["rocky"] = "road"
  82    >>> C["rocky"]["path"] = "/cookie"
  83    >>> print C.output(header="Cookie:")
  84    Cookie: rocky=road; Path=/cookie
  85    >>> print C.output(attrs=[], header="Cookie:")
  86    Cookie: rocky=road
  87
  88 The load() method of a Cookie extracts cookies from a string.  In a
  89 CGI script, you would use this method to extract the cookies from the
  90 HTTP_COOKIE environment variable.
  91
  92    >>> C = Cookie.SmartCookie()
  93    >>> C.load("chips=ahoy; vienna=finger")
  94    >>> C.output()
  95    'Set-Cookie: chips=ahoy\r\nSet-Cookie: vienna=finger'
  96
  97 The load() method is darn-tootin smart about identifying cookies
  98 within a string.  Escaped quotation marks, nested semicolons, and other
  99 such trickeries do not confuse it.
 100
 101    >>> C = Cookie.SmartCookie()
 102    >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
 103    >>> print C
 104    Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;"
 105
 106 Each element of the Cookie also supports all of the RFC 2109
 107 Cookie attributes.  Here's an example which sets the Path
 108 attribute.
 109
 110    >>> C = Cookie.SmartCookie()
 111    >>> C["oreo"] = "doublestuff"
 112    >>> C["oreo"]["path"] = "/"
 113    >>> print C
 114    Set-Cookie: oreo=doublestuff; Path=/
 115
 116 Each dictionary element has a 'value' attribute, which gives you
 117 back the value associated with the key.
 118
 119    >>> C = Cookie.SmartCookie()
 120    >>> C["twix"] = "none for you"
 121    >>> C["twix"].value
 122    'none for you'
 123
 124
 125 A Bit More Advanced
 126 -------------------
 127
 128 As mentioned before, there are three different flavors of Cookie
 129 objects, each with different encoding/decoding semantics.  This
 130 section briefly discusses the differences.
 131
 132 SimpleCookie
 133
 134 The SimpleCookie expects that all values should be standard strings.
 135 Just to be sure, SimpleCookie invokes the str() builtin to convert
 136 the value to a string, when the values are set dictionary-style.
 137
 138    >>> C = Cookie.SimpleCookie()
 139    >>> C["number"] = 7
 140    >>> C["string"] = "seven"
 141    >>> C["number"].value
 142    '7'
 143    >>> C["string"].value
 144    'seven'
 145    >>> C.output()
 146    'Set-Cookie: number=7\r\nSet-Cookie: string=seven'
 147
 148
 149 SerialCookie
 150
 151 The SerialCookie expects that all values should be serialized using
 152 cPickle (or pickle, if cPickle isn't available).  As a result of
 153 serializing, SerialCookie can save almost any Python object to a
 154 value, and recover the exact same object when the cookie has been
 155 returned.  (SerialCookie can yield some strange-looking cookie
 156 values, however.)
 157
 158    >>> C = Cookie.SerialCookie()
 159    >>> C["number"] = 7
 160    >>> C["string"] = "seven"
 161    >>> C["number"].value
 162    7
 163    >>> C["string"].value
 164    'seven'
 165    >>> C.output()
 166    'Set-Cookie: number="I7\\012."\r\nSet-Cookie: string="S\'seven\'\\012p1\\012."'
 167
 168 Be warned, however, if SerialCookie cannot de-serialize a value (because
 169 it isn't a valid pickle'd object), IT WILL RAISE AN EXCEPTION.
 170
 171
 172 SmartCookie
 173
 174 The SmartCookie combines aspects of each of the other two flavors.
 175 When setting a value in a dictionary-fashion, the SmartCookie will
 176 serialize (ala cPickle) the value *if and only if* it isn't a
 177 Python string.  String objects are *not* serialized.  Similarly,
 178 when the load() method parses out values, it attempts to de-serialize
 179 the value.  If it fails, then it fallsback to treating the value
 180 as a string.
 181
 182    >>> C = Cookie.SmartCookie()
 183    >>> C["number"] = 7
 184    >>> C["string"] = "seven"
 185    >>> C["number"].value
 186    7
 187    >>> C["string"].value
 188    'seven'
 189    >>> C.output()
 190    'Set-Cookie: number="I7\\012."\r\nSet-Cookie: string=seven'
 191
 192
 193 Backwards Compatibility
 194 -----------------------
 195
 196 In order to keep compatibilty with earlier versions of Cookie.py,
 197 it is still possible to use Cookie.Cookie() to create a Cookie.  In
 198 fact, this simply returns a SmartCookie.
 199
 200    >>> C = Cookie.Cookie()
 201    >>> print C.__class__.__name__
 202    SmartCookie
 203
 204
 205 Finis.
 206 """  #"
 207 #     ^
 208 #     |----helps out font-lock
 209
 210 #
 211 # Import our required modules
 212 #
 213 import string
 214
 215 try:
 216     from cPickle import dumps, loads
 217 except ImportError:
 218     from pickle import dumps, loads
 219
 220 import re, warnings
 221
 222 __all__ = ["CookieError","BaseCookie","SimpleCookie","SerialCookie",
 223            "SmartCookie","Cookie"]
 224
 225 _nulljoin = ''.join
 226 _semispacejoin = '; '.join
 227 _spacejoin = ' '.join
 228
 229 #
 230 # Define an exception visible to External modules
 231 #
 232 class CookieError(Exception):
 233     pass
 234
 235
 236 # These quoting routines conform to the RFC2109 specification, which in
 237 # turn references the character definitions from RFC2068.  They provide
 238 # a two-way quoting algorithm.  Any non-text character is translated
 239 # into a 4 character sequence: a forward-slash followed by the
 240 # three-digit octal equivalent of the character.  Any '\' or '"' is
 241 # quoted with a preceeding '\' slash.
 242 #
 243 # These are taken from RFC2068 and RFC2109.
 244 #       _LegalChars       is the list of chars which don't require "'s
 245 #       _Translator       hash-table for fast quoting
 246 #
 247 _LegalChars       = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~"
 248 _Translator       = {
 249     '\000' : '\\000',  '\001' : '\\001',  '\002' : '\\002',
 250     '\003' : '\\003',  '\004' : '\\004',  '\005' : '\\005',
 251     '\006' : '\\006',  '\007' : '\\007',  '\010' : '\\010',
 252     '\011' : '\\011',  '\012' : '\\012',  '\013' : '\\013',
 253     '\014' : '\\014',  '\015' : '\\015',  '\016' : '\\016',
 254     '\017' : '\\017',  '\020' : '\\020',  '\021' : '\\021',
 255     '\022' : '\\022',  '\023' : '\\023',  '\024' : '\\024',
 256     '\025' : '\\025',  '\026' : '\\026',  '\027' : '\\027',
 257     '\030' : '\\030',  '\031' : '\\031',  '\032' : '\\032',
 258     '\033' : '\\033',  '\034' : '\\034',  '\035' : '\\035',
 259     '\036' : '\\036',  '\037' : '\\037',
 260
 261     # Because of the way browsers really handle cookies (as opposed
 262     # to what the RFC says) we also encode , and ;
 263
 264     ',' : '\\054', ';' : '\\073',
 265
 266     '"' : '\\"',       '\\' : '\\\\',
 267
 268     '\177' : '\\177',  '\200' : '\\200',  '\201' : '\\201',
 269     '\202' : '\\202',  '\203' : '\\203',  '\204' : '\\204',
 270     '\205' : '\\205',  '\206' : '\\206',  '\207' : '\\207',
 271     '\210' : '\\210',  '\211' : '\\211',  '\212' : '\\212',
 272     '\213' : '\\213',  '\214' : '\\214',  '\215' : '\\215',
 273     '\216' : '\\216',  '\217' : '\\217',  '\220' : '\\220',
 274     '\221' : '\\221',  '\222' : '\\222',  '\223' : '\\223',
 275     '\224' : '\\224',  '\225' : '\\225',  '\226' : '\\226',
 276     '\227' : '\\227',  '\230' : '\\230',  '\231' : '\\231',
 277     '\232' : '\\232',  '\233' : '\\233',  '\234' : '\\234',
 278     '\235' : '\\235',  '\236' : '\\236',  '\237' : '\\237',
 279     '\240' : '\\240',  '\241' : '\\241',  '\242' : '\\242',
 280     '\243' : '\\243',  '\244' : '\\244',  '\245' : '\\245',
 281     '\246' : '\\246',  '\247' : '\\247',  '\250' : '\\250',
 282     '\251' : '\\251',  '\252' : '\\252',  '\253' : '\\253',
 283     '\254' : '\\254',  '\255' : '\\255',  '\256' : '\\256',
 284     '\257' : '\\257',  '\260' : '\\260',  '\261' : '\\261',
 285     '\262' : '\\262',  '\263' : '\\263',  '\264' : '\\264',
 286     '\265' : '\\265',  '\266' : '\\266',  '\267' : '\\267',
 287     '\270' : '\\270',  '\271' : '\\271',  '\272' : '\\272',
 288     '\273' : '\\273',  '\274' : '\\274',  '\275' : '\\275',
 289     '\276' : '\\276',  '\277' : '\\277',  '\300' : '\\300',
 290     '\301' : '\\301',  '\302' : '\\302',  '\303' : '\\303',
 291     '\304' : '\\304',  '\305' : '\\305',  '\306' : '\\306',
 292     '\307' : '\\307',  '\310' : '\\310',  '\311' : '\\311',
 293     '\312' : '\\312',  '\313' : '\\313',  '\314' : '\\314',
 294     '\315' : '\\315',  '\316' : '\\316',  '\317' : '\\317',
 295     '\320' : '\\320',  '\321' : '\\321',  '\322' : '\\322',
 296     '\323' : '\\323',  '\324' : '\\324',  '\325' : '\\325',
 297     '\326' : '\\326',  '\327' : '\\327',  '\330' : '\\330',
 298     '\331' : '\\331',  '\332' : '\\332',  '\333' : '\\333',
 299     '\334' : '\\334',  '\335' : '\\335',  '\336' : '\\336',
 300     '\337' : '\\337',  '\340' : '\\340',  '\341' : '\\341',
 301     '\342' : '\\342',  '\343' : '\\343',  '\344' : '\\344',
 302     '\345' : '\\345',  '\346' : '\\346',  '\347' : '\\347',
 303     '\350' : '\\350',  '\351' : '\\351',  '\352' : '\\352',
 304     '\353' : '\\353',  '\354' : '\\354',  '\355' : '\\355',
 305     '\356' : '\\356',  '\357' : '\\357',  '\360' : '\\360',
 306     '\361' : '\\361',  '\362' : '\\362',  '\363' : '\\363',
 307     '\364' : '\\364',  '\365' : '\\365',  '\366' : '\\366',
 308     '\367' : '\\367',  '\370' : '\\370',  '\371' : '\\371',
 309     '\372' : '\\372',  '\373' : '\\373',  '\374' : '\\374',
 310     '\375' : '\\375',  '\376' : '\\376',  '\377' : '\\377'
 311     }
 312
 313 _idmap = ''.join(chr(x) for x in xrange(256))
 314
 315 def _quote(str, LegalChars=_LegalChars,
 316            idmap=_idmap, translate=string.translate):
 317     #
 318     # If the string does not need to be double-quoted,
 319     # then just return the string.  Otherwise, surround
 320     # the string in doublequotes and precede quote (with a \)
 321     # special characters.
 322     #
 323     if "" == translate(str, idmap, LegalChars):
 324         return str
 325     else:
 326         return '"' + _nulljoin( map(_Translator.get, str, str) ) + '"'
 327 # end _quote
 328
 329
 330 _OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
 331 _QuotePatt = re.compile(r"[\\].")
 332
 333 def _unquote(str):
 334     # If there aren't any doublequotes,
 335     # then there can't be any special characters.  See RFC 2109.
 336     if  len(str) < 2:
 337         return str
 338     if str[0] != '"' or str[-1] != '"':
 339         return str
 340
 341     # We have to assume that we must decode this string.
 342     # Down to work.
 343
 344     # Remove the "s
 345     str = str[1:-1]
 346
 347     # Check for special sequences.  Examples:
 348     #    \012 --> \n
 349     #    \"   --> "
 350     #
 351     i = 0
 352     n = len(str)
 353     res = []
 354     while 0 <= i < n:
 355         Omatch = _OctalPatt.search(str, i)
 356         Qmatch = _QuotePatt.search(str, i)
 357         if not Omatch and not Qmatch:              # Neither matched
 358             res.append(str[i:])
 359             break
 360         # else:
 361         j = k = -1
 362         if Omatch: j = Omatch.start(0)
 363         if Qmatch: k = Qmatch.start(0)
 364         if Qmatch and ( not Omatch or k < j ):     # QuotePatt matched
 365             res.append(str[i:k])
 366             res.append(str[k+1])
 367             i = k+2
 368         else:                                      # OctalPatt matched
 369             res.append(str[i:j])
 370             res.append( chr( int(str[j+1:j+4], 8) ) )
 371             i = j+4
 372     return _nulljoin(res)
 373 # end _unquote
 374
 375 # The _getdate() routine is used to set the expiration time in
 376 # the cookie's HTTP header.      By default, _getdate() returns the
 377 # current time in the appropriate "expires" format for a
 378 # Set-Cookie header.     The one optional argument is an offset from
 379 # now, in seconds.      For example, an offset of -3600 means "one hour ago".
 380 # The offset may be a floating point number.
 381 #
 382
 383 _weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
 384
 385 _monthname = [None,
 386               'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
 387               'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
 388
 389 def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
 390     from time import gmtime, time
 391     now = time()
 392     year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
 393     return "%s, %02d-%3s-%4d %02d:%02d:%02d GMT" % \
 394            (weekdayname[wd], day, monthname[month], year, hh, mm, ss)
 395
 396
 397 #
 398 # A class to hold ONE key,value pair.
 399 # In a cookie, each such pair may have several attributes.
 400 #       so this class is used to keep the attributes associated
 401 #       with the appropriate key,value pair.
 402 # This class also includes a coded_value attribute, which
 403 #       is used to hold the network representation of the
 404 #       value.  This is most useful when Python objects are
 405 #       pickled for network transit.
 406 #
 407
 408 class Morsel(dict):
 409     # RFC 2109 lists these attributes as reserved:
 410     #   path       comment         domain
 411     #   max-age    secure      version
 412     #
 413     # For historical reasons, these attributes are also reserved:
 414     #   expires
 415     #
 416     # This is an extension from Microsoft:
 417     #   httponly
 418     #
 419     # This dictionary provides a mapping from the lowercase
 420     # variant on the left to the appropriate traditional
 421     # formatting on the right.
 422     _reserved = { "expires" : "expires",
 423                    "path"        : "Path",
 424                    "comment" : "Comment",
 425                    "domain"      : "Domain",
 426                    "max-age" : "Max-Age",
 427                    "secure"      : "secure",
 428                    "httponly"  : "httponly",
 429                    "version" : "Version",
 430                    }
 431
 432     def __init__(self):
 433         # Set defaults
 434         self.key = self.value = self.coded_value = None
 435
 436         # Set default attributes
 437         for K in self._reserved:
 438             dict.__setitem__(self, K, "")
 439     # end __init__
 440
 441     def __setitem__(self, K, V):
 442         K = K.lower()
 443         if not K in self._reserved:
 444             raise CookieError("Invalid Attribute %s" % K)
 445         dict.__setitem__(self, K, V)
 446     # end __setitem__
 447
 448     def isReservedKey(self, K):
 449         return K.lower() in self._reserved
 450     # end isReservedKey
 451
 452     def set(self, key, val, coded_val,
 453             LegalChars=_LegalChars,
 454             idmap=_idmap, translate=string.translate):
 455         # First we verify that the key isn't a reserved word
 456         # Second we make sure it only contains legal characters
 457         if key.lower() in self._reserved:
 458             raise CookieError("Attempt to set a reserved key: %s" % key)
 459         if "" != translate(key, idmap, LegalChars):
 460             raise CookieError("Illegal key value: %s" % key)
 461
 462         # It's a good key, so save it.
 463         self.key                 = key
 464         self.value               = val
 465         self.coded_value         = coded_val
 466     # end set
 467
 468     def output(self, attrs=None, header = "Set-Cookie:"):
 469         return "%s %s" % ( header, self.OutputString(attrs) )
 470
 471     __str__ = output
 472
 473     def __repr__(self):
 474         return '<%s: %s=%s>' % (self.__class__.__name__,
 475                                 self.key, repr(self.value) )
 476
 477     def js_output(self, attrs=None):
 478         # Print javascript
 479         return """
 480         <script type="text/javascript">
 481         <!-- begin hiding
 482         document.cookie = \"%s\";
 483         // end hiding -->
 484         </script>
 485         """ % ( self.OutputString(attrs).replace('"',r'\"'), )
 486     # end js_output()
 487
 488     def OutputString(self, attrs=None):
 489         # Build up our result
 490         #
 491         result = []
 492         RA = result.append
 493
 494         # First, the key=value pair
 495         RA("%s=%s" % (self.key, self.coded_value))
 496
 497         # Now add any defined attributes
 498         if attrs is None:
 499             attrs = self._reserved
 500         items = self.items()
 501         items.sort()
 502         for K,V in items:
 503             if V == "": continue
 504             if K not in attrs: continue
 505             if K == "expires" and type(V) == type(1):
 506                 RA("%s=%s" % (self._reserved[K], _getdate(V)))
 507             elif K == "max-age" and type(V) == type(1):
 508                 RA("%s=%d" % (self._reserved[K], V))
 509             elif K == "secure":
 510                 RA(str(self._reserved[K]))
 511             elif K == "httponly":
 512                 RA(str(self._reserved[K]))
 513             else:
 514                 RA("%s=%s" % (self._reserved[K], V))
 515
 516         # Return the result
 517         return _semispacejoin(result)
 518     # end OutputString
 519 # end Morsel class
 520
 521
 522
 523 #
 524 # Pattern for finding cookie
 525 #
 526 # This used to be strict parsing based on the RFC2109 and RFC2068
 527 # specifications.  I have since discovered that MSIE 3.0x doesn't
 528 # follow the character rules outlined in those specs.  As a
 529 # result, the parsing rules here are less strict.
 530 #
 531
 532 _LegalCharsPatt  = r"[\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{\=]"
 533 _CookiePattern = re.compile(
 534     r"(?x)"                       # This is a Verbose pattern
 535     r"(?P<key>"                   # Start of group 'key'
 536     ""+ _LegalCharsPatt +"+?"     # Any word of at least one letter, nongreedy
 537     r")"                          # End of group 'key'
 538     r"\s*=\s*"                    # Equal Sign
 539     r"(?P<val>"                   # Start of group 'val'
 540     r'"(?:[^\\"]|\\.)*"'            # Any doublequoted string
 541     r"|"                            # or
 542     r"\w{3},\s[\w\d-]{9,11}\s[\d:]{8}\sGMT" # Special case for "expires" attr
 543     r"|"                            # or
 544     ""+ _LegalCharsPatt +"*"        # Any word or empty string
 545     r")"                          # End of group 'val'
 546     r"\s*;?"                      # Probably ending in a semi-colon
 547     )
 548
 549
 550 # At long last, here is the cookie class.
 551 #   Using this class is almost just like using a dictionary.
 552 # See this module's docstring for example usage.
 553 #
 554 class BaseCookie(dict):
 555     # A container class for a set of Morsels
 556     #
 557
 558     def value_decode(self, val):
 559         """real_value, coded_value = value_decode(STRING)
 560         Called prior to setting a cookie's value from the network
 561         representation.  The VALUE is the value read from HTTP
 562         header.
 563         Override this function to modify the behavior of cookies.
 564         """
 565         return val, val
 566     # end value_encode
 567
 568     def value_encode(self, val):
 569         """real_value, coded_value = value_encode(VALUE)
 570         Called prior to setting a cookie's value from the dictionary
 571         representation.  The VALUE is the value being assigned.
 572         Override this function to modify the behavior of cookies.
 573         """
 574         strval = str(val)
 575         return strval, strval
 576     # end value_encode
 577
 578     def __init__(self, input=None):
 579         if input: self.load(input)
 580     # end __init__
 581
 582     def __set(self, key, real_value, coded_value):
 583         """Private method for setting a cookie's value"""
 584         M = self.get(key, Morsel())
 585         M.set(key, real_value, coded_value)
 586         dict.__setitem__(self, key, M)
 587     # end __set
 588
 589     def __setitem__(self, key, value):
 590         """Dictionary style assignment."""
 591         rval, cval = self.value_encode(value)
 592         self.__set(key, rval, cval)
 593     # end __setitem__
 594
 595     def output(self, attrs=None, header="Set-Cookie:", sep="\015\012"):
 596         """Return a string suitable for HTTP."""
 597         result = []
 598         items = self.items()
 599         items.sort()
 600         for K,V in items:
 601             result.append( V.output(attrs, header) )
 602         return sep.join(result)
 603     # end output
 604
 605     __str__ = output
 606
 607     def __repr__(self):
 608         L = []
 609         items = self.items()
 610         items.sort()
 611         for K,V in items:
 612             L.append( '%s=%s' % (K,repr(V.value) ) )
 613         return '<%s: %s>' % (self.__class__.__name__, _spacejoin(L))
 614
 615     def js_output(self, attrs=None):
 616         """Return a string suitable for JavaScript."""
 617         result = []
 618         items = self.items()
 619         items.sort()
 620         for K,V in items:
 621             result.append( V.js_output(attrs) )
 622         return _nulljoin(result)
 623     # end js_output
 624
 625     def load(self, rawdata):
 626         """Load cookies from a string (presumably HTTP_COOKIE) or
 627         from a dictionary.  Loading cookies from a dictionary 'd'
 628         is equivalent to calling:
 629             map(Cookie.__setitem__, d.keys(), d.values())
 630         """
 631         if type(rawdata) == type(""):
 632             self.__ParseString(rawdata)
 633         else:
 634             # self.update() wouldn't call our custom __setitem__
 635             for k, v in rawdata.items():
 636                 self[k] = v
 637         return
 638     # end load()
 639
 640     def __ParseString(self, str, patt=_CookiePattern):
 641         i = 0            # Our starting point
 642         n = len(str)     # Length of string
 643         M = None         # current morsel
 644
 645         while 0 <= i < n:
 646             # Start looking for a cookie
 647             match = patt.search(str, i)
 648             if not match: break          # No more cookies
 649
 650             K,V = match.group("key"), match.group("val")
 651             i = match.end(0)
 652
 653             # Parse the key, value in case it's metainfo
 654             if K[0] == "$":
 655                 # We ignore attributes which pertain to the cookie
 656                 # mechanism as a whole.  See RFC 2109.
 657                 # (Does anyone care?)
 658                 if M:
 659                     M[ K[1:] ] = V
 660             elif K.lower() in Morsel._reserved:
 661                 if M:
 662                     M[ K ] = _unquote(V)
 663             else:
 664                 rval, cval = self.value_decode(V)
 665                 self.__set(K, rval, cval)
 666                 M = self[K]
 667     # end __ParseString
 668 # end BaseCookie class
 669
 670 class SimpleCookie(BaseCookie):
 671     """SimpleCookie
 672     SimpleCookie supports strings as cookie values.  When setting
 673     the value using the dictionary assignment notation, SimpleCookie
 674     calls the builtin str() to convert the value to a string.  Values
 675     received from HTTP are kept as strings.
 676     """
 677     def value_decode(self, val):
 678         return _unquote( val ), val
 679     def value_encode(self, val):
 680         strval = str(val)
 681         return strval, _quote( strval )
 682 # end SimpleCookie
 683
 684 class SerialCookie(BaseCookie):
 685     """SerialCookie
 686     SerialCookie supports arbitrary objects as cookie values. All
 687     values are serialized (using cPickle) before being sent to the
 688     client.  All incoming values are assumed to be valid Pickle
 689     representations.  IF AN INCOMING VALUE IS NOT IN A VALID PICKLE
 690     FORMAT, THEN AN EXCEPTION WILL BE RAISED.
 691
 692     Note: Large cookie values add overhead because they must be
 693     retransmitted on every HTTP transaction.
 694
 695     Note: HTTP has a 2k limit on the size of a cookie.  This class
 696     does not check for this limit, so be careful!!!
 697     """
 698     def __init__(self, input=None):
 699         warnings.warn("SerialCookie class is insecure; do not use it",
 700                       DeprecationWarning)
 701         BaseCookie.__init__(self, input)
 702     # end __init__
 703     def value_decode(self, val):
 704         # This could raise an exception!
 705         return loads( _unquote(val) ), val
 706     def value_encode(self, val):
 707         return val, _quote( dumps(val) )
 708 # end SerialCookie
 709
 710 class SmartCookie(BaseCookie):
 711     """SmartCookie
 712     SmartCookie supports arbitrary objects as cookie values.  If the
 713     object is a string, then it is quoted.  If the object is not a
 714     string, however, then SmartCookie will use cPickle to serialize
 715     the object into a string representation.
 716
 717     Note: Large cookie values add overhead because they must be
 718     retransmitted on every HTTP transaction.
 719
 720     Note: HTTP has a 2k limit on the size of a cookie.  This class
 721     does not check for this limit, so be careful!!!
 722     """
 723     def __init__(self, input=None):
 724         warnings.warn("Cookie/SmartCookie class is insecure; do not use it",
 725                       DeprecationWarning)
 726         BaseCookie.__init__(self, input)
 727     # end __init__
 728     def value_decode(self, val):
 729         strval = _unquote(val)
 730         try:
 731             return loads(strval), val
 732         except:
 733             return strval, val
 734     def value_encode(self, val):
 735         if type(val) == type(""):
 736             return val, _quote(val)
 737         else:
 738             return val, _quote( dumps(val) )
 739 # end SmartCookie
 740
 741
 742 ###########################################################
 743 # Backwards Compatibility:  Don't break any existing code!
 744
 745 # We provide Cookie() as an alias for SmartCookie()
 746 Cookie = SmartCookie
 747
 748 #
 749 ###########################################################
 750
 751 def _test():
 752     import doctest, Cookie
 753     return doctest.testmod(Cookie)
 754
 755 if __name__ == "__main__":
 756     _test()
 757
 758
 759 #Local Variables:
 760 #tab-width: 4
 761 #end: