o [h@s8ddlmZmZmZddlmZmZmZddlTddl Tzddl m Z Wne y3ddl m Z YnwddlZddlZddlZddlZddlZddlZddlmZddlmZeZdZdZd ZdZdZd Zd Z d Z!d Z"d Z#dZ$dZ%dZ&dZ'dZ(gdZ)dZ*d Z+dZ,dZ-dZ.dZ/dZ0dZ1dZ2dZ3dZ4dZ5erddZ6ddZ7ddZ8n d dZ6d!dZ7d"dZ8e9d#Z:d$Z;d%e:d&e;d'Ze=Z?d*Z@d+d,ZAGd-d.d.eZBGd/d0d0eZCGd1d2d2eZDGd3d4d4eDZEGd5d6d6eDZFGd7d8d8eDZGGd9d:d:eZHd;ifdNr$cCs|SNr r!r r r#r$OscCs tt|Sr&)byteslistbr r r#r$Ps cCs|Sr&)lowerr!r r r#r$Rr%cCst|Sr&)ordr!r r r#r$Sr%cCsdt|SN)joinr(r)r r r#r$Tss()<>@,;:\"/[]?={} s"(?:\\.|[^"])*"s(?:[^s]+|)s (?:;|^)\s*([^s ]+)\s*=\s*("cCs|sdifSt|tr|d}d|vr|ifS|dd\}}i}t|D]I}|d}|d}|dt krU|dt krU|dd}| dd  d d }|d krp|dd dksi|dddkrp|d d}|||<q+||fS)zq Parses a Content-Type header into a value in the following format: (content_type, {parameters}) r.latin-1;rr rs\\\s\""filenamers:\N) isinstancerencoder+stripsplit OPTION_REfinditergroupQUOTEreplace)valuectyperestoptionsmatchkeyr r r#parse_options_headeras&      rGc@s|eZdZdZddZeddZddZdd Zd d Z d d Z ddZ ddZ e ddZe ddZddZddZdS)FieldaA Field object represents a (parsed) form field. It represents a single field with a corresponding name and value. The name that a :class:`Field` will be instantiated with is the same name that would be found in the following HTML:: This class defines two methods, :meth:`on_data` and :meth:`on_end`, that will be called when data is written to the Field, and when the Field is finalized, respectively. :param name: the name of the form field cCs||_g|_t|_dSr&)_name_value_missing_cache)selfnamer r r#__init__s zField.__init__cCs0||}|dur |n||||S)aKCreate an instance of a :class:`Field`, and set the corresponding value - either None or an actual value. This method will also finalize the Field itself. :param name: the name of the form field :param value: the value of the form field - either a bytestring or None N)set_nonewritefinalize)klassrNrAfr r r# from_values    zField.from_valuecC ||S)zPWrite some data into the form field. :param data: a bytestring on_datarMdatar r r#rQ z Field.writecCs|j|t|_t|S)zThis method is a callback that will be called whenever data is written to the Field. :param data: a bytestring )rJappendrKrLlenrYr r r#rXs z Field.on_datacCs |jturd|j|_dSdS)?This method is called whenever the Field is finalized. r.NrLrKr/rJrMr r r#on_ends z Field.on_endcC |dS)z!Finalize the form field. Nrar`r r r#rRs zField.finalizecCs |jtur d|j|_|`dS)zFClose the Field object. This will free any underlying cache. r.Nr_r`r r r#closes z Field.closecCs d|_dS)aSome fields in a querystring can possibly have a value of None - for example, the string "foo&bar=&baz=asdf" will have a field with the name "foo" and value None, one with name "bar" and value "", and one with name "baz" and value "asdf". Since the write() interface doesn't support writing None, this function will set the field value to None. N)rLr`r r r#rPs zField.set_nonecC|jS)z,This property returns the name of the field.)rIr`r r r# field_nameszField.field_namecCs|jtur d|j|_|jS)z2This property returns the value of the form field.r.r_r`r r r#rAs z Field.valuecCs&t|tr|j|jko|j|jkStSr&)r8rHrfrANotImplemented)rMotherr r r#__eq__s   z Field.__eq__cCsLt|jdkrt|jddddd}nt|j}d|jj|j|fS)Nrr4z...'z%s(field_name=%r, value=%s))r]rArepr __class____name__rf)rMvr r r#__repr__s  zField.__repr__N)rl __module__ __qualname____doc__rO classmethodrUrQrXrarRrdrPpropertyrfrArirnr r r r#rHs"      rHc@seZdZdZdifddZeddZeddZed d Zed d Z ed dZ eddZ ddZ ddZ ddZddZddZddZddZdd ZdS)!Filea This class represents an uploaded file. It handles writing file data to either an in-memory file or a temporary file on-disk, if the optional threshold is passed. There are some options that can be passed to the File to change behavior of the class. Valid options are as follows: .. list-table:: :widths: 15 5 5 30 :header-rows: 1 * - Name - Type - Default - Description * - UPLOAD_DIR - `str` - None - The directory to store uploaded files in. If this is None, a temporary file will be created in the system's standard location. * - UPLOAD_DELETE_TMP - `bool` - True - Delete automatically created TMP file * - UPLOAD_KEEP_FILENAME - `bool` - False - Whether or not to keep the filename of the uploaded file. If True, then the filename will be converted to a safe representation (e.g. by removing any invalid path segments), and then saved with the same name). Otherwise, a temporary name will be used. * - UPLOAD_KEEP_EXTENSIONS - `bool` - False - Whether or not to keep the uploaded file's extension. If False, the file will be saved with the default temporary extension (usually ".tmp"). Otherwise, the file's extension will be maintained. Note that this will properly combine with the UPLOAD_KEEP_FILENAME setting. * - MAX_MEMORY_FILE_SIZE - `int` - 1 MiB - The maximum number of bytes of a File to keep in memory. By default, the contents of a File are kept into memory until a certain limit is reached, after which the contents of the File are written to a temporary file. This behavior can be disabled by setting this value to an appropriately large value (or, for example, infinity, such as `float('inf')`. :param file_name: The name of the file that this :class:`File` represents :param field_name: The field name that uploaded this file. Note that this can be None, if, for example, the file was uploaded with Content-Type application/octet-stream :param config: The configuration for this File. See above for valid configuration keys and their corresponding values. NcCsdtt|_||_d|_d|_t|_||_ ||_ d|_ |dur0t j |\}}||_||_dSdS)NTr)logging getLoggerrllogger_config _in_memory_bytes_writtenr _fileobj _field_name _file_name_actual_file_nameospathsplitext _file_base_ext)rM file_namerfconfigbaseextr r r#rOAs  z File.__init__cCre)zThe form field associated with this file. May be None if there isn't one, for example when we have an application/octet-stream upload. )r|r`r r r#rfWzFile.field_namecCre)z3The file name given in the upload request. )r}r`r r r#r^szFile.file_namecCre)zmThe file name that this file is saved as. Will be None if it's not currently saved on disk. )r~r`r r r#actual_file_namedrzFile.actual_file_namecCre)zThe file object that we're currently writing to. Note that this will either be an instance of a :class:`io.BytesIO`, or a regular file object. )r{r`r r r# file_objectkszFile.file_objectcCre)zzThe total size of this file, counted as the number of bytes that currently have been written to the file. )rzr`r r r#sizesrz File.sizecCre)zqA boolean representing whether or not this file object is currently stored in-memory or on-disk. )ryr`r r r# in_memoryzrzFile.in_memorycCsb|js |jddS|jd|}t|j|||j|j}||_d|_| dS)aFIf the file is already on-disk, do nothing. Otherwise, copy from the in-memory buffer to a disk file, and then reassign our internal file object to this new disk file. Note that if you attempt to flush a file that is already on-disk, a warning will be logged to this module's logger. z0Trying to flush to disk when we're not in memoryNrF) ryrwwarningr{seek_get_disk_fileshutil copyfileobjrzrd)rMnew_fileZ old_fileobjr r r# flush_to_disks   zFile.flush_to_diskc Cs|jd|jd}|jdd}|jdd}|jdd}|durj|rj|jd ||j}|r8||j}tj||}z|jd |t |d }Wnt t fyi}zd}|j d t d |d}~wwi} |r|j} t| tr}| t} | | d<|dur|} t| tr| t} | | d<|| d<|jd| z tjdi| }Wnt t fy|j dt dw|j}t|tr|t}||_|S)zOThis function is responsible for getting a file object on-disk for us. zOpening a file on disk UPLOAD_DIRUPLOAD_KEEP_FILENAMEFUPLOAD_KEEP_EXTENSIONSZUPLOAD_DELETE_TMPTNzSaving with filename in: %rzOpening file: %rzw+bzError opening temporary filez Error opening temporary file: %rsuffixdirdeletez*Creating a temporary file with options: %rz#Error creating named temporary filer )rwinforxgetrrrrr/openIOErrorOSError exceptionZ FileErrorr8rdecodesysgetfilesystemencodingtempfileNamedTemporaryFilerNrr9r~) rMZfile_dirZ keep_filenameZkeep_extensionsZ delete_tmpfnamerZtmp_fileerDrdr r r#rs\           zFile._get_disk_filecCrV)zHWrite some data to the File. :param data: a bytestring rWrYr r r#rQr[z File.writecCs|j}|j|}|dur|j|}|t|kr(|jd|t||S|j|7_|jrM|j ddurM|j|j dkrM|j d| |S)zThis method is a callback that will be called whenever data is written to the File. :param data: a bytestring Nz bwritten != len(data) (%d != %d)MAX_MEMORY_FILE_SIZEzFlushing to disk) r{tellrQr]rwrrzryrxrrr)rMrZposZbwrittenr r r#rXs$      z File.on_datacC|jdS)r^N)r{flushr`r r r#raz File.on_endcCrb)zFinalize the form file. This will not close the underlying file, but simply signal that we are finished writing to the File. Nrcr`r r r#rRs z File.finalizecCr)zClose the File object. This will actually close the underlying file object (whether it's a :class:`io.BytesIO` or an actual file object). N)r{rdr`r r r#rdsz File.closecCd|jj|j|jfS)Nz%s(file_name=%r, field_name=%r))rkrlrrfr`r r r#rn! z File.__repr__)rlrorprqrOrsrfrrrrrrrrQrXrarRrdrnr r r r#rts.:      $B  rtc@sBeZdZdZddZdddZddZd d Zd d Zd dZ dS) BaseParseraThis class is the base class for all parsers. It contains the logic for calling and adding callbacks. A callback can be one of two different forms. "Notification callbacks" are callbacks that are called when something happens - for example, when a new part of a multipart message is encountered by the parser. "Data callbacks" are called when we get some sort of data - for example, part of the body of a multipart chunk. Notification callbacks are called with no parameters, whereas data callbacks are called with three, as follows:: data_callback(data, start, end) The "data" parameter is a bytestring (i.e. "foo" on Python 2, or b"foo" on Python 3). "start" and "end" are integer indexes into the "data" string that represent the data of interest. Thus, in a data callback, the slice `data[start:end]` represents the data that the callback is "interested in". The callback is not passed a copy of the data, since copying severely hurts performance. cCstt|_dSr&)rurvrlrwr`r r r#rO=szBaseParser.__init__NcCsvd|}|j|}|durdS|dur/|dur||krdS|jd|||||||dS|jd||dS)aThis function calls a provided callback with some data. If the callback is not set, will do nothing. :param name: The name of the callback to call (as a string). :param data: Data to pass to the callback. If None, then it is assumed that the callback is a notification callback, and no parameters are given. :param end: An integer that is passed to the data callback. :param start: An integer that is passed to the data callback. on_NzCalling %s with data[%d:%d]zCalling %s with no data) callbacksrrwdebug)rMrNrZstartendfuncr r r#callback@s  zBaseParser.callbackcCs0|dur|jd|ddS||jd|<dS)aqUpdate the function for a callback. Removes from the callbacks dict if new_func is None. :param name: The name of the callback to call (as a string). :param new_func: The new function for the callback. If None, then the callback will be removed (with no error if it does not exist). Nr)rpop)rMrNnew_funcr r r# set_callback_s zBaseParser.set_callbackcCdSr&r r`r r r#rdnzBaseParser.closecCrr&r r`r r r#rRqrzBaseParser.finalizecC d|jjSNz%s()rkrlr`r r r#rnt zBaseParser.__repr__)NNN) rlrorprqrOrrrdrRrnr r r r#r)s  rcsBeZdZdZiedffdd ZddZddZd d ZZ S) OctetStreamParseraThis parser parses an octet-stream request body and calls callbacks when incoming data is received. Callbacks are as follows: .. list-table:: :widths: 15 10 30 :header-rows: 1 * - Callback Name - Parameters - Description * - on_start - None - Called when the first data is parsed. * - on_data - data, start, end - Called for each data chunk that is parsed. * - on_end - None - Called when the parser is finished parsing all data. :param callbacks: A dictionary of callbacks. See the documentation for :class:`BaseParser`. :param max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. infcsHtt|||_d|_t|tr|dkrtd|||_d|_ dSNFr*max_size must be a positive number, not %rr) superrrOr_startedr8r ValueErrormax_size _current_size)rMrrrkr r#rOs zOctetStreamParser.__init__cCs||js |dd|_t|}|j||jkr-t|j|j}|jd|j|j|||}|j|7_|d|d||S)zWrite some data to the parser, which will perform size verification, and then pass the data to the underlying callback. :param data: a bytestring rTDCurrent size is %d (max %d), so truncating data length from %d to %drZr)rrr]rrintrwr)rMrZdata_lennew_sizer r r#rQs  zOctetStreamParser.writecCs|ddS)ztFinalize this parser, which signals to that we are finished parsing, and sends the on_end callback. rN)rr`r r r#rRrzOctetStreamParser.finalizecCrrrr`r r r#rnrzOctetStreamParser.__repr__) rlrorprqfloatrOrQrRrn __classcell__r r rr#rxs  rcsLeZdZdZidedffdd ZddZdd Zd d Zd d Z Z S)QuerystringParsera This is a streaming querystring parser. It will consume data, and call the callbacks given when it has data. .. list-table:: :widths: 15 10 30 :header-rows: 1 * - Callback Name - Parameters - Description * - on_field_start - None - Called when a new field is encountered. * - on_field_name - data, start, end - Called when a portion of a field's name is encountered. * - on_field_data - data, start, end - Called when a portion of a field's data is encountered. * - on_field_end - None - Called when the end of a field is encountered. * - on_end - None - Called when the parser is finished parsing all data. :param callbacks: A dictionary of callbacks. See the documentation for :class:`BaseParser`. :param strict_parsing: Whether or not to parse the body strictly. Defaults to False. If this is set to True, then the behavior of the parser changes as the following: if a field has a value with an equal sign (e.g. "foo=bar", or "foo="), it is always included. If a field has no equals sign (e.g. "...&name&..."), it will be treated as an error if 'strict_parsing' is True, otherwise included. If an error is encountered, then a :class:`multipart.exceptions.QuerystringParseError` will be raised. :param max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. FrcsTtt|t|_d|_||_t|tr|dkrt d|||_ d|_ ||_ dSr) rrrOSTATE_BEFORE_FIELDstate _found_seprr8r rrrstrict_parsing)rMrrrrr r#rOs zQuerystringParser.__init__c Czt|}|j||jkr"t|j|j}|jd|j|j|||}d}z|||}W|j|7_|S|j|7_w)aWrite some data to the parser, which will perform size verification, parse into either a field name or value, and then pass the corresponding data to the underlying callback. If an error is encountered while parsing, a QuerystringParseError will be raised. The "offset" attribute of the raised exception will be set to the offset in the input data chunk (NOT the overall stream) that caused the error. :param data: a bytestring rrr]rrrrwr_internal_writerMrZrrlr r r#rQ  zQuerystringParser.writec Cs:|j}|j}|j}d}||kr||}|tkrH|tks |tkr:|r7|r/td|}||_||j d|nd}n| d|d8}t }d}n|t kr| d|} | dkr\| d |} | dkrh| d || } n| d |} | dkr| d ||| | }t }n|s| dkr| d ||| | d | d}t}nr| d ||||}ng| dkrtd |f}||_|| d ||||}nL|t kr| d|} | dkr| d |} | dkr| d||| | d | d}t}n | d||||}nd||f} |j| t| }||_||d7}||ks||_||_t|S)Nrz,Skipping duplicate ampersand/semicolon at %dTZ field_startrF&r4r3=rf field_endz{When strict_parsing is True, we require an equals sign in all field chunks. Did not find one in the chunk that starts at %dZ field_data!Reached an unknown state %d at %d)rrrr AMPERSAND SEMICOLONZQuerystringParseErroroffsetrwrrSTATE_FIELD_NAMEfindSTATE_FIELD_DATArr]) rMrZlengthrrZ found_sepichrZsep_posZ equals_posmsgr r r#rs           z!QuerystringParser._internal_writecCs"|jtkr |d|ddS)zFinalize this parser, which signals to that we are finished parsing, if we're still in the middle of a field, an on_field_end callback, and then the on_end callback. rrN)rrrr`r r r#rRs  zQuerystringParser.finalizecCsd|jj|j|j|jfS)Nz8%s(keep_blank_values=%r, strict_parsing=%r, max_size=%r))rkrlkeep_blank_valuesrrr`r r r#rns zQuerystringParser.__repr__ rlrorprqrrOrQrrRrnrr r rr#rs, rcsJeZdZdZiedffdd ZddZddZd d Zd d Z Z S) MultipartParsera#This class is a streaming multipart/form-data parser. .. list-table:: :widths: 15 10 30 :header-rows: 1 * - Callback Name - Parameters - Description * - on_part_begin - None - Called when a new part of the multipart message is encountered. * - on_part_data - data, start, end - Called when a portion of a part's data is encountered. * - on_part_end - None - Called when the end of a part is reached. * - on_header_begin - None - Called when we've found a new header in a part of a multipart message * - on_header_field - data, start, end - Called each time an additional portion of a header is read (i.e. the part of the header that is before the colon; the "Foo" in "Foo: Bar"). * - on_header_value - data, start, end - Called when we get data for a header. * - on_header_end - None - Called when the current header is finished - i.e. we've reached the newline at the end of the header. * - on_headers_finished - None - Called when all headers are finished, and before the part data starts. * - on_end - None - Called when the parser is finished parsing all data. :param boundary: The multipart boundary. This is required, and must match what is given in the HTTP request - usually in the Content-Type header. :param callbacks: A dictionary of callbacks. See the documentation for :class:`BaseParser`. :param max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. rcstt|t|_d|_|_||_t|t r|dkr"t d|||_ d|_ i|_ t|tr5|d}d||_t|j|_ddtt|dD|_dS) Nrrrr2s --cSsg|]}tqSr )NULL).0xr r r# sz,MultipartParser.__init__..r)rrrO STATE_STARTrindexflagsrr8r rrrmarksrr9boundary frozensetboundary_charsranger] lookbehind)rMrrrrr r#rOs      zMultipartParser.__init__c Cr)aWrite some data to the parser, which will perform size verification, and then parse the data into the appropriate location (e.g. header, data, etc.), and pass this on to the underlying callback. If an error is encountered, a MultipartParseError will be raised. The "offset" attribute on the raised exception will be set to the offset of the byte in the input chunk that caused the error. :param data: a bytestring rrrrr r r#rQrzMultipartParser.writecs*j}j}j}j}dfdd}dfdd }dfdd } kr} |tkrQ| tks;| tkrGd 7jd q&d}t }d 8n|t kr|t |d kr{| tkrud f} j | t | } | _ | |d 7}nx|t |d d kr| tkrd f} j | t | } | _ | d}dt}nK| ||d krd| |d f} j | t | } | _ | |d 7}n&|tkrd}|dt}d 8n|tkrH| tkr|dt}d 7q&|d 7}| tkrn| tkr#|d krdf} j | t | } | _ | | dt}nt| } | tks1| tkrFd| f} j | t | } | _ | n|tkrc| tkrWd 7q&|dt}d 8n|tkrz| tkrx| ddt}ny|tkr| tkrd| f} j | t | } | _ | t}nW|tkr| tkrd| f} j | t | } | _ | dt}n0|tkr|dt}d 8n|tkr|}t |}|d }}j}|dkr|7|d kr|vr|7|d kr|vs|8} ||kr6||| kr3|dkr.| d|d 7}nmd}nj||krV|d 7}| tkrI|tO}nW| tkrS|tO}nMd}nJ||d kr|t@r| tkr|tM}ddd}t}d 7q&d}|tM}n|t@r| tkrddt }nd}|dkr| j!|d <nF|dkrt"j!}d|d|d}|dd 8n)|t kr| ttfvr݈j d| nd|f} j | t | } | _ | d 7ks+| dd| dd| dd|_|_|_S)Nrcsj|<dSr&)r)rN)rrMr r#set_markHsz1MultipartParser._internal_write..set_markFcsj|ddSr&)rr)rNresetr`r r# delete_markLz4MultipartParser._internal_write..delete_markcs\j|}|dur dS|r||dj|<dS||j|ddS)Nr)rrrr)rN remainingZ marked_indexrZrrrMr r# data_callbackTs z6MultipartParser._internal_write..data_callbackrzSkipping leading CR/LF at %dr z'Did not find CR at end of boundary (%d)z'Did not find LF at end of boundary (%d)Z part_beginz.Did not find boundary character %r at index %dZ header_fieldzFound 0-length header at %dz3Found non-alphanumeric character %r in header at %d header_valueZ header_endz5Did not find LF character at end of header (found %r)z,Did not find LF at end of headers (found %r)Zheaders_finishedZ part_dataZpart_endrz(Consuming a byte '0x%x' in the end staterT)F)#rrrrrCRLFrwrSTATE_START_BOUNDARYr]rZMultipartParseErrorrrSTATE_HEADER_FIELD_STARTSTATE_HEADER_FIELDSTATE_HEADERS_ALMOST_DONEHYPHENCOLONSTATE_HEADER_VALUE_START lower_charLOWER_ALOWER_ZSPACESTATE_HEADER_VALUESTATE_HEADER_VALUE_ALMOST_DONESTATE_PART_DATA_STARTSTATE_PART_DATArFLAG_PART_BOUNDARYFLAG_LAST_BOUNDARY STATE_ENDr join_bytes)rMrZrrrrrrrrr"rrclZ prev_indexZboundary_lengthZ boundary_endZ data_lengthrZlb_datar rr#r:s|                                                              Q  zMultipartParser._internal_writecCsdS)a'Finalize this parser, which signals to that we are finished parsing. Note: It does not currently, but in the future, it will verify that we are in the final state of the parser (i.e. the end of the multipart message is well-formed), and, if not, throw an error. Nr r`r r r#rRs zMultipartParser.finalizecCsd|jj|jfS)Nz%s(boundary=%r))rkrlrr`r r r#rnrzMultipartParser.__repr__rr r rr#rs6(  rc@s\eZdZdZedddddddZdddeeifddZd d Z d d Z d dZ ddZ dS) FormParsera This class is the all-in-one form parser. Given all the information necessary to parse a form, it will instantiate the correct parser, create the proper :class:`Field` and :class:`File` classes to store the data that is parsed, and call the two given callbacks with each field and file as they become available. :param content_type: The Content-Type of the incoming request. This is used to select the appropriate parser. :param on_field: The callback to call when a field has been parsed and is ready for usage. See above for parameters. :param on_file: The callback to call when a file has been parsed and is ready for usage. See above for parameters. :param on_end: An optional callback to call when all fields and files in a request has been parsed. Can be None. :param boundary: If the request is a multipart/form-data request, this should be the boundary of the request, as given in the Content-Type header, as a bytestring. :param file_name: If the request is of type application/octet-stream, then the body of the request will not contain any information about the uploaded file. In such cases, you can provide the file name of the uploaded file manually. :param FileClass: The class to use for uploaded files. Defaults to :class:`File`, but you can provide your own class if you wish to customize behaviour. The class will be instantiated as FileClass(file_name, field_name), and it must provide the folllowing functions:: file_instance.write(data) file_instance.finalize() file_instance.close() :param FieldClass: The class to use for uploaded fields. Defaults to :class:`Field`, but you can provide your own class if you wish to customize behaviour. The class will be instantiated as FieldClass(field_name), and it must provide the folllowing functions:: field_instance.write(data) field_instance.finalize() field_instance.close() :param config: Configuration to use for this FormParser. The default values are taken from the DEFAULT_CONFIG value, and then any keys present in this dictionary will overwrite the default values. rNF) MAX_BODY_SIZErrrrUPLOAD_ERROR_ON_BAD_CTEc  sLtt _| _| _d _d _ _ _ | _ t _ t _ j _ j| |dkr`Gdddt  fdd} fdd}  fd d }| | |d } t| jd d } n|dksh|dkrgGdddt dd}fdd} fdd} fdd} fdd }|||||d} t| jd d} n||dkr|dur jdtdggiGdddt dd } fd!d"} fd#d$}fd%d&}fd'd(}fd)d*} fd+d,} fd-d }||||||||d.} t|| jd d } n jd/|td0|| _dS)1Nrzapplication/octet-streamc@eZdZdZdS!FormParser.__init__..varsNrlrorprTr r r r#vars.r csdjd_dS)Nr)rrTr ) FileClassrrMr r r#on_start1z%FormParser.__init__..on_startcsj|||dSr&)rTrQrZrrr r r#rX4sz$FormParser.__init__..on_datacs.jjjdurdSdSr&)rTrRrar )on_filerMr r r#ra7s    z#FormParser.__init__..on_end)r$rXrar)rz!application/x-www-form-urlencodedzapplication/x-url-encodedc@rrrr r r r#r Qr!cSrr&r r r r r#on_field_startTrz+FormParser.__init__..on_field_startc|||dSr&r\r&) name_bufferr r# on_field_nameWr%z*FormParser.__init__..on_field_namecs<jdurd_dd=j|||dSr-)rTr/rQr&) FieldClassr,r r r# on_field_dataZs  z*FormParser.__init__..on_field_datacsLjdurd_dd=jjjd_dSr-)rTr/rPrRr )r.r,on_fieldr r r# on_field_end`s      z)FormParser.__init__..on_field_endcsjdur dSdSr&rcr r`r r#rams  )r)r-r/r1ra)rrzmultipart/form-datazNo boundary givenc@seZdZdZdZdZdS)rNF)rlrorprTwriteris_filer r r r#r scSrr&r r r r r# on_part_beginrz*FormParser.__init__..on_part_begincsj|||}|Sr&)r2rQ)rZrrZbytes_processedr'r r# on_part_datasz)FormParser.__init__..on_part_datacs,jjrjdSjdSr&)rTrRr3r )r0r(r r r# on_part_ends z(FormParser.__init__..on_part_endcr*r&r+r&) header_namer r#on_header_fieldr%z,FormParser.__init__..on_header_fieldcr*r&r+r&)rr r#on_header_valuer%z,FormParser.__init__..on_header_valuecs,dd<dd=dd=dSr-)r/r )r7rheadersr r# on_header_ends z*FormParser.__init__..on_header_endcsd_d}t|\}}|d}|d}|dur"|_n ||jd_d_dd}|d ks@|d ks@|dkrFj_dS|d krRtj_dS|d kr^tj_dSj d |jdrqt d |j_dS)NFsContent-Dispositionsnamer7r"TsContent-Transfer-Encodings7bitsbinarys8bitsbase64squoted-printablez%Unknown Content-Transfer-Encoding: %rrz'Unknown Content-Transfer-Encoding "{0}") r3rrGrTrr2Z Base64DecoderZQuotedPrintableDecoderrwrFormParserErrorformat)Z content_dispZdisprDrfrZtransfer_encoding)r.r#r:rMr r r#on_headers_finisheds<        z0FormParser.__init__..on_headers_finishedcs$jjdurdSdSr&)r2rRrar )rMr r r#ras   )r4r5r6r8r9r;r>razUnknown Content-Type: %rzUnknown Content-Type: {0})rurvrlrw content_typerbytes_receivedparserr0r(rartr#rHr.DEFAULT_CONFIGcopyrupdateobjectrrerrorr<rrr=)rMr?r0r(rarrr#r.rr$rXrrAr)r-r/r1r4r5r6r8r9r;r>r ) r.r#rr7rr:r,r0r(rMr r#rOs             4  zFormParser.__init__cCs|jt|7_|j|S)zWrite some data. The parser will forward this to the appropriate underlying parser. :param data: a bytestring )r@r]rArQrYr r r#rQs zFormParser.writecC,|jdurt|jdr|jdSdSdS)zFinalize the parser.NrR)rAhasattrrRr`r r r#rRzFormParser.finalizecCrG)zClose the parser.Nrd)rArHrdr`r r r#rd rIzFormParser.closecCr)Nz%s(content_type=%r, parser=%r))rkrlr?rAr`r r r#rnrzFormParser.__repr__) rlrorprqrrBrtrHrOrQrRrdrnr r r r#rs$6  i  rFc Csl|d}|durttdtdt|\}}|d}|d}|d}t||||||d} | S) a:This function is a helper function to aid in creating a FormParser instances. Given a dictionary-like headers object, it will determine the correct information needed, instantiate a FormParser with the appropriate values and given callbacks, and then return the corresponding parser. :param headers: A dictionary-like object of HTTP headers. The only required header is Content-Type. :param on_field: Callback to call with each parsed field. :param on_file: Callback to call with each parsed file. :param trust_x_headers: Whether or not to trust information received from certain X-Headers - for example, the file name from X-File-Name. :param config: Configuration variables to pass to the FormParser. z Content-TypeNzNo Content-Type header givenzNo Content-Type header given!sboundaryr2z X-File-Name)rrr) rrurvrlrrrGrr) r:r0r(Ztrust_x_headersrr?paramsrrZ form_parserr r r#create_form_parsers     rKrc Kst|||}|d}|durt|}ntd}d} t||d} || } || |t| 7}t| | ks<||kr=nq|dS)aHThis function is useful if you just want to parse a request body, without too much work. Pass it a dictionary-like object of the request's headers, and a file-like object for the input stream, along with two callbacks that will get called whenever a field or file is parsed. :param headers: A dictionary-like object of HTTP headers. The only required header is Content-Type. :param input_stream: A file-like object that represents the request body. The read() method must return bytestrings. :param on_field: Callback to call with each parsed field. :param on_file: Callback to call with each parsed file. :param chunk_size: The maximum size to read from the input stream and write to the parser at one time. Defaults to 1 MiB. zContent-LengthNrrTr) rKrrrminreadrQr]rR) r:Z input_streamr0r( chunk_sizekwargsrAcontent_lengthZ bytes_readZ max_readableZbuffr r r# parse_formGs       rQ)r)K __future__rrrsixrrrZdecoders exceptionsurlparser ImportError urllib.parserrerrrurior numbersr rErKrrrrrrrr rrrrrZSTATE_PART_DATA_ENDrZSTATESrrrrr rrrrr r rr Zord_charrescape SPECIAL_CHARSZ QUOTED_STRZ VALUE_STRZ OPTION_RE_STRcompiler<r?rGrHrtrrrrrrKrQr r r r#s      )|%OJ}G 1