Merge pull request #278 from nmav/ocserv
[project/luci.git] / modules / base / luasrc / http / protocol.lua
1 --[[
2
3 HTTP protocol implementation for LuCI
4 (c) 2008 Freifunk Leipzig / Jo-Philipp Wich <xm@leipzig.freifunk.net>
5
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
9
10         http://www.apache.org/licenses/LICENSE-2.0
11
12 $Id$
13
14 ]]--
15
16 --- LuCI http protocol class.
17 -- This class contains several functions useful for http message- and content
18 -- decoding and to retrive form data from raw http messages.
19 module("luci.http.protocol", package.seeall)
20
21 local ltn12 = require("luci.ltn12")
22
23 HTTP_MAX_CONTENT      = 1024*8          -- 8 kB maximum content size
24
25 --- Decode an urlencoded string - optionally without decoding
26 -- the "+" sign to " " - and return the decoded string.
27 -- @param str           Input string in x-www-urlencoded format
28 -- @param no_plus       Don't decode "+" signs to spaces
29 -- @return                      The decoded string
30 -- @see                         urlencode
31 function urldecode( str, no_plus )
32
33         local function __chrdec( hex )
34                 return string.char( tonumber( hex, 16 ) )
35         end
36
37         if type(str) == "string" then
38                 if not no_plus then
39                         str = str:gsub( "+", " " )
40                 end
41
42                 str = str:gsub( "%%([a-fA-F0-9][a-fA-F0-9])", __chrdec )
43         end
44
45         return str
46 end
47
48 --- Extract and split urlencoded data pairs, separated bei either "&" or ";"
49 -- from given url or string. Returns a table with urldecoded values.
50 -- Simple parameters are stored as string values associated with the parameter
51 -- name within the table. Parameters with multiple values are stored as array
52 -- containing the corresponding values.
53 -- @param url   The url or string which contains x-www-urlencoded form data
54 -- @param tbl   Use the given table for storing values (optional)
55 -- @return              Table containing the urldecoded parameters
56 -- @see                 urlencode_params
57 function urldecode_params( url, tbl )
58
59         local params = tbl or { }
60
61         if url:find("?") then
62                 url = url:gsub( "^.+%?([^?]+)", "%1" )
63         end
64
65         for pair in url:gmatch( "[^&;]+" ) do
66
67                 -- find key and value
68                 local key = urldecode( pair:match("^([^=]+)")     )
69                 local val = urldecode( pair:match("^[^=]+=(.+)$") )
70
71                 -- store
72                 if type(key) == "string" and key:len() > 0 then
73                         if type(val) ~= "string" then val = "" end
74
75                         if not params[key] then
76                                 params[key] = val
77                         elseif type(params[key]) ~= "table" then
78                                 params[key] = { params[key], val }
79                         else
80                                 table.insert( params[key], val )
81                         end
82                 end
83         end
84
85         return params
86 end
87
88 --- Encode given string to x-www-urlencoded format.
89 -- @param str   String to encode
90 -- @return              String containing the encoded data
91 -- @see                 urldecode
92 function urlencode( str )
93
94         local function __chrenc( chr )
95                 return string.format(
96                         "%%%02x", string.byte( chr )
97                 )
98         end
99
100         if type(str) == "string" then
101                 str = str:gsub(
102                         "([^a-zA-Z0-9$_%-%.%+!*'(),])",
103                         __chrenc
104                 )
105         end
106
107         return str
108 end
109
110 --- Encode each key-value-pair in given table to x-www-urlencoded format,
111 -- separated by "&". Tables are encoded as parameters with multiple values by
112 -- repeating the parameter name with each value.
113 -- @param tbl   Table with the values
114 -- @return              String containing encoded values
115 -- @see                 urldecode_params
116 function urlencode_params( tbl )
117         local enc = ""
118
119         for k, v in pairs(tbl) do
120                 if type(v) == "table" then
121                         for i, v2 in ipairs(v) do
122                                 enc = enc .. ( #enc > 0 and "&" or "" ) ..
123                                         urlencode(k) .. "=" .. urlencode(v2)
124                         end
125                 else
126                         enc = enc .. ( #enc > 0 and "&" or "" ) ..
127                                 urlencode(k) .. "=" .. urlencode(v)
128                 end
129         end
130
131         return enc
132 end
133
134 -- (Internal function)
135 -- Initialize given parameter and coerce string into table when the parameter
136 -- already exists.
137 -- @param tbl   Table where parameter should be created
138 -- @param key   Parameter name
139 -- @return              Always nil
140 local function __initval( tbl, key )
141         if tbl[key] == nil then
142                 tbl[key] = ""
143         elseif type(tbl[key]) == "string" then
144                 tbl[key] = { tbl[key], "" }
145         else
146                 table.insert( tbl[key], "" )
147         end
148 end
149
150 -- (Internal function)
151 -- Append given data to given parameter, either by extending the string value
152 -- or by appending it to the last string in the parameter's value table.
153 -- @param tbl   Table containing the previously initialized parameter value
154 -- @param key   Parameter name
155 -- @param chunk String containing the data to append
156 -- @return              Always nil
157 -- @see                 __initval
158 local function __appendval( tbl, key, chunk )
159         if type(tbl[key]) == "table" then
160                 tbl[key][#tbl[key]] = tbl[key][#tbl[key]] .. chunk
161         else
162                 tbl[key] = tbl[key] .. chunk
163         end
164 end
165
166 -- (Internal function)
167 -- Finish the value of given parameter, either by transforming the string value
168 -- or - in the case of multi value parameters - the last element in the
169 -- associated values table.
170 -- @param tbl           Table containing the previously initialized parameter value
171 -- @param key           Parameter name
172 -- @param handler       Function which transforms the parameter value
173 -- @return                      Always nil
174 -- @see                         __initval
175 -- @see                         __appendval
176 local function __finishval( tbl, key, handler )
177         if handler then
178                 if type(tbl[key]) == "table" then
179                         tbl[key][#tbl[key]] = handler( tbl[key][#tbl[key]] )
180                 else
181                         tbl[key] = handler( tbl[key] )
182                 end
183         end
184 end
185
186
187 -- Table of our process states
188 local process_states = { }
189
190 -- Extract "magic", the first line of a http message.
191 -- Extracts the message type ("get", "post" or "response"), the requested uri
192 -- or the status code if the line descripes a http response.
193 process_states['magic'] = function( msg, chunk, err )
194
195         if chunk ~= nil then
196                 -- ignore empty lines before request
197                 if #chunk == 0 then
198                         return true, nil
199                 end
200
201                 -- Is it a request?
202                 local method, uri, http_ver = chunk:match("^([A-Z]+) ([^ ]+) HTTP/([01]%.[019])$")
203
204                 -- Yup, it is
205                 if method then
206
207                         msg.type           = "request"
208                         msg.request_method = method:lower()
209                         msg.request_uri    = uri
210                         msg.http_version   = tonumber( http_ver )
211                         msg.headers        = { }
212
213                         -- We're done, next state is header parsing
214                         return true, function( chunk )
215                                 return process_states['headers']( msg, chunk )
216                         end
217
218                 -- Is it a response?
219                 else
220
221                         local http_ver, code, message = chunk:match("^HTTP/([01]%.[019]) ([0-9]+) ([^\r\n]+)$")
222
223                         -- Is a response
224                         if code then
225
226                                 msg.type           = "response"
227                                 msg.status_code    = code
228                                 msg.status_message = message
229                                 msg.http_version   = tonumber( http_ver )
230                                 msg.headers        = { }
231
232                                 -- We're done, next state is header parsing
233                                 return true, function( chunk )
234                                         return process_states['headers']( msg, chunk )
235                                 end
236                         end
237                 end
238         end
239
240         -- Can't handle it
241         return nil, "Invalid HTTP message magic"
242 end
243
244
245 -- Extract headers from given string.
246 process_states['headers'] = function( msg, chunk )
247
248         if chunk ~= nil then
249
250                 -- Look for a valid header format
251                 local hdr, val = chunk:match( "^([A-Za-z][A-Za-z0-9%-_]+): +(.+)$" )
252
253                 if type(hdr) == "string" and hdr:len() > 0 and
254                    type(val) == "string" and val:len() > 0
255                 then
256                         msg.headers[hdr] = val
257
258                         -- Valid header line, proceed
259                         return true, nil
260
261                 elseif #chunk == 0 then
262                         -- Empty line, we won't accept data anymore
263                         return false, nil
264                 else
265                         -- Junk data
266                         return nil, "Invalid HTTP header received"
267                 end
268         else
269                 return nil, "Unexpected EOF"
270         end
271 end
272
273
274 --- Creates a ltn12 source from the given socket. The source will return it's
275 -- data line by line with the trailing \r\n stripped of.
276 -- @param sock  Readable network socket
277 -- @return              Ltn12 source function
278 function header_source( sock )
279         return ltn12.source.simplify( function()
280
281                 local chunk, err, part = sock:receive("*l")
282
283                 -- Line too long
284                 if chunk == nil then
285                         if err ~= "timeout" then
286                                 return nil, part
287                                         and "Line exceeds maximum allowed length"
288                                         or  "Unexpected EOF"
289                         else
290                                 return nil, err
291                         end
292
293                 -- Line ok
294                 elseif chunk ~= nil then
295
296                         -- Strip trailing CR
297                         chunk = chunk:gsub("\r$","")
298
299                         return chunk, nil
300                 end
301         end )
302 end
303
304 --- Decode a mime encoded http message body with multipart/form-data
305 -- Content-Type. Stores all extracted data associated with its parameter name
306 -- in the params table withing the given message object. Multiple parameter
307 -- values are stored as tables, ordinary ones as strings.
308 -- If an optional file callback function is given then it is feeded with the
309 -- file contents chunk by chunk and only the extracted file name is stored
310 -- within the params table. The callback function will be called subsequently
311 -- with three arguments:
312 --  o Table containing decoded (name, file) and raw (headers) mime header data
313 --  o String value containing a chunk of the file data
314 --  o Boolean which indicates wheather the current chunk is the last one (eof)
315 -- @param src           Ltn12 source function
316 -- @param msg           HTTP message object
317 -- @param filecb        File callback function (optional)
318 -- @return                      Value indicating successful operation (not nil means "ok")
319 -- @return                      String containing the error if unsuccessful
320 -- @see                         parse_message_header
321 function mimedecode_message_body( src, msg, filecb )
322
323         if msg and msg.env.CONTENT_TYPE then
324                 msg.mime_boundary = msg.env.CONTENT_TYPE:match("^multipart/form%-data; boundary=(.+)$")
325         end
326
327         if not msg.mime_boundary then
328                 return nil, "Invalid Content-Type found"
329         end
330
331
332         local tlen   = 0
333         local inhdr  = false
334         local field  = nil
335         local store  = nil
336         local lchunk = nil
337
338         local function parse_headers( chunk, field )
339
340                 local stat
341                 repeat
342                         chunk, stat = chunk:gsub(
343                                 "^([A-Z][A-Za-z0-9%-_]+): +([^\r\n]+)\r\n",
344                                 function(k,v)
345                                         field.headers[k] = v
346                                         return ""
347                                 end
348                         )
349                 until stat == 0
350
351                 chunk, stat = chunk:gsub("^\r\n","")
352
353                 -- End of headers
354                 if stat > 0 then
355                         if field.headers["Content-Disposition"] then
356                                 if field.headers["Content-Disposition"]:match("^form%-data; ") then
357                                         field.name = field.headers["Content-Disposition"]:match('name="(.-)"')
358                                         field.file = field.headers["Content-Disposition"]:match('filename="(.+)"$')
359                                 end
360                         end
361
362                         if not field.headers["Content-Type"] then
363                                 field.headers["Content-Type"] = "text/plain"
364                         end
365
366                         if field.name and field.file and filecb then
367                                 __initval( msg.params, field.name )
368                                 __appendval( msg.params, field.name, field.file )
369
370                                 store = filecb
371                         elseif field.name then
372                                 __initval( msg.params, field.name )
373
374                                 store = function( hdr, buf, eof )
375                                         __appendval( msg.params, field.name, buf )
376                                 end
377                         else
378                                 store = nil
379                         end
380
381                         return chunk, true
382                 end
383
384                 return chunk, false
385         end
386
387         local function snk( chunk )
388
389                 tlen = tlen + ( chunk and #chunk or 0 )
390
391                 if msg.env.CONTENT_LENGTH and tlen > tonumber(msg.env.CONTENT_LENGTH) + 2 then
392                         return nil, "Message body size exceeds Content-Length"
393                 end
394
395                 if chunk and not lchunk then
396                         lchunk = "\r\n" .. chunk
397
398                 elseif lchunk then
399                         local data = lchunk .. ( chunk or "" )
400                         local spos, epos, found
401
402                         repeat
403                                 spos, epos = data:find( "\r\n--" .. msg.mime_boundary .. "\r\n", 1, true )
404
405                                 if not spos then
406                                         spos, epos = data:find( "\r\n--" .. msg.mime_boundary .. "--\r\n", 1, true )
407                                 end
408
409
410                                 if spos then
411                                         local predata = data:sub( 1, spos - 1 )
412
413                                         if inhdr then
414                                                 predata, eof = parse_headers( predata, field )
415
416                                                 if not eof then
417                                                         return nil, "Invalid MIME section header"
418                                                 elseif not field.name then
419                                                         return nil, "Invalid Content-Disposition header"
420                                                 end
421                                         end
422
423                                         if store then
424                                                 store( field, predata, true )
425                                         end
426
427
428                                         field = { headers = { } }
429                                         found = found or true
430
431                                         data, eof = parse_headers( data:sub( epos + 1, #data ), field )
432                                         inhdr = not eof
433                                 end
434                         until not spos
435
436                         if found then
437                                 -- We found at least some boundary. Save
438                                 -- the unparsed remaining data for the
439                                 -- next chunk.
440                                 lchunk, data = data, nil
441                         else
442                                 -- There was a complete chunk without a boundary. Parse it as headers or
443                                 -- append it as data, depending on our current state.
444                                 if inhdr then
445                                         lchunk, eof = parse_headers( data, field )
446                                         inhdr = not eof
447                                 else
448                                         -- We're inside data, so append the data. Note that we only append
449                                         -- lchunk, not all of data, since there is a chance that chunk
450                                         -- contains half a boundary. Assuming that each chunk is at least the
451                                         -- boundary in size, this should prevent problems
452                                         store( field, lchunk, false )
453                                         lchunk, chunk = chunk, nil
454                                 end
455                         end
456                 end
457
458                 return true
459         end
460
461         return ltn12.pump.all( src, snk )
462 end
463
464 --- Decode an urlencoded http message body with application/x-www-urlencoded
465 -- Content-Type. Stores all extracted data associated with its parameter name
466 -- in the params table withing the given message object. Multiple parameter
467 -- values are stored as tables, ordinary ones as strings.
468 -- @param src   Ltn12 source function
469 -- @param msg   HTTP message object
470 -- @return              Value indicating successful operation (not nil means "ok")
471 -- @return              String containing the error if unsuccessful
472 -- @see                 parse_message_header
473 function urldecode_message_body( src, msg )
474
475         local tlen   = 0
476         local lchunk = nil
477
478         local function snk( chunk )
479
480                 tlen = tlen + ( chunk and #chunk or 0 )
481
482                 if msg.env.CONTENT_LENGTH and tlen > tonumber(msg.env.CONTENT_LENGTH) + 2 then
483                         return nil, "Message body size exceeds Content-Length"
484                 elseif tlen > HTTP_MAX_CONTENT then
485                         return nil, "Message body size exceeds maximum allowed length"
486                 end
487
488                 if not lchunk and chunk then
489                         lchunk = chunk
490
491                 elseif lchunk then
492                         local data = lchunk .. ( chunk or "&" )
493                         local spos, epos
494
495                         repeat
496                                 spos, epos = data:find("^.-[;&]")
497
498                                 if spos then
499                                         local pair = data:sub( spos, epos - 1 )
500                                         local key  = pair:match("^(.-)=")
501                                         local val  = pair:match("=([^%s]*)%s*$")
502
503                                         if key and #key > 0 then
504                                                 __initval( msg.params, key )
505                                                 __appendval( msg.params, key, val )
506                                                 __finishval( msg.params, key, urldecode )
507                                         end
508
509                                         data = data:sub( epos + 1, #data )
510                                 end
511                         until not spos
512
513                         lchunk = data
514                 end
515
516                 return true
517         end
518
519         return ltn12.pump.all( src, snk )
520 end
521
522 --- Try to extract an http message header including information like protocol
523 -- version, message headers and resulting CGI environment variables from the
524 -- given ltn12 source.
525 -- @param src   Ltn12 source function
526 -- @return              HTTP message object
527 -- @see                 parse_message_body
528 function parse_message_header( src )
529
530         local ok   = true
531         local msg  = { }
532
533         local sink = ltn12.sink.simplify(
534                 function( chunk )
535                         return process_states['magic']( msg, chunk )
536                 end
537         )
538
539         -- Pump input data...
540         while ok do
541
542                 -- get data
543                 ok, err = ltn12.pump.step( src, sink )
544
545                 -- error
546                 if not ok and err then
547                         return nil, err
548
549                 -- eof
550                 elseif not ok then
551
552                         -- Process get parameters
553                         if ( msg.request_method == "get" or msg.request_method == "post" ) and
554                            msg.request_uri:match("?")
555                         then
556                                 msg.params = urldecode_params( msg.request_uri )
557                         else
558                                 msg.params = { }
559                         end
560
561                         -- Populate common environment variables
562                         msg.env = {
563                                 CONTENT_LENGTH    = msg.headers['Content-Length'];
564                                 CONTENT_TYPE      = msg.headers['Content-Type'] or msg.headers['Content-type'];
565                                 REQUEST_METHOD    = msg.request_method:upper();
566                                 REQUEST_URI       = msg.request_uri;
567                                 SCRIPT_NAME       = msg.request_uri:gsub("?.+$","");
568                                 SCRIPT_FILENAME   = "";         -- XXX implement me
569                                 SERVER_PROTOCOL   = "HTTP/" .. string.format("%.1f", msg.http_version);
570                                 QUERY_STRING      = msg.request_uri:match("?")
571                                         and msg.request_uri:gsub("^.+?","") or ""
572                         }
573
574                         -- Populate HTTP_* environment variables
575                         for i, hdr in ipairs( {
576                                 'Accept',
577                                 'Accept-Charset',
578                                 'Accept-Encoding',
579                                 'Accept-Language',
580                                 'Connection',
581                                 'Cookie',
582                                 'Host',
583                                 'Referer',
584                                 'User-Agent',
585                         } ) do
586                                 local var = 'HTTP_' .. hdr:upper():gsub("%-","_")
587                                 local val = msg.headers[hdr]
588
589                                 msg.env[var] = val
590                         end
591                 end
592         end
593
594         return msg
595 end
596
597 --- Try to extract and decode a http message body from the given ltn12 source.
598 -- This function will examine the Content-Type within the given message object
599 -- to select the appropriate content decoder.
600 -- Currently the application/x-www-urlencoded and application/form-data
601 -- mime types are supported. If the encountered content encoding can't be
602 -- handled then the whole message body will be stored unaltered as "content"
603 -- property within the given message object.
604 -- @param src           Ltn12 source function
605 -- @param msg           HTTP message object
606 -- @param filecb        File data callback (optional, see mimedecode_message_body())
607 -- @return                      Value indicating successful operation (not nil means "ok")
608 -- @return                      String containing the error if unsuccessful
609 -- @see                         parse_message_header
610 function parse_message_body( src, msg, filecb )
611         -- Is it multipart/mime ?
612         if msg.env.REQUEST_METHOD == "POST" and msg.env.CONTENT_TYPE and
613            msg.env.CONTENT_TYPE:match("^multipart/form%-data")
614         then
615
616                 return mimedecode_message_body( src, msg, filecb )
617
618         -- Is it application/x-www-form-urlencoded ?
619         elseif msg.env.REQUEST_METHOD == "POST" and msg.env.CONTENT_TYPE and
620                msg.env.CONTENT_TYPE:match("^application/x%-www%-form%-urlencoded")
621         then
622                 return urldecode_message_body( src, msg, filecb )
623
624
625         -- Unhandled encoding
626         -- If a file callback is given then feed it chunk by chunk, else
627         -- store whole buffer in message.content
628         else
629
630                 local sink
631
632                 -- If we have a file callback then feed it
633                 if type(filecb) == "function" then
634                         sink = filecb
635
636                 -- ... else append to .content
637                 else
638                         msg.content = ""
639                         msg.content_length = 0
640
641                         sink = function( chunk, err )
642                                 if chunk then
643                                         if ( msg.content_length + #chunk ) <= HTTP_MAX_CONTENT then
644                                                 msg.content        = msg.content        .. chunk
645                                                 msg.content_length = msg.content_length + #chunk
646                                                 return true
647                                         else
648                                                 return nil, "POST data exceeds maximum allowed length"
649                                         end
650                                 end
651                                 return true
652                         end
653                 end
654
655                 -- Pump data...
656                 while true do
657                         local ok, err = ltn12.pump.step( src, sink )
658
659                         if not ok and err then
660                                 return nil, err
661                         elseif not ok then -- eof
662                                 return true
663                         end
664                 end
665
666                 return true
667         end
668 end
669
670 --- Table containing human readable messages for several http status codes.
671 -- @class table
672 statusmsg = {
673         [200] = "OK",
674         [206] = "Partial Content",
675         [301] = "Moved Permanently",
676         [302] = "Found",
677         [304] = "Not Modified",
678         [400] = "Bad Request",
679         [403] = "Forbidden",
680         [404] = "Not Found",
681         [405] = "Method Not Allowed",
682         [408] = "Request Time-out",
683         [411] = "Length Required",
684         [412] = "Precondition Failed",
685         [416] = "Requested range not satisfiable",
686         [500] = "Internal Server Error",
687         [503] = "Server Unavailable",
688 }