1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/http/http.v

245 lines
5.5 KiB
V
Raw Normal View History

2019-06-23 05:21:30 +03:00
// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
2019-06-22 21:20:28 +03:00
module http
2019-08-06 15:43:09 +03:00
import net.urllib
2019-08-07 04:57:47 +03:00
import http.chunked
2019-08-06 15:43:09 +03:00
const (
max_redirects = 4
)
2019-10-24 19:44:49 +03:00
pub struct Request {
2019-06-22 21:20:28 +03:00
pub:
2019-10-24 19:44:49 +03:00
headers map[string]string
2019-06-22 21:20:28 +03:00
method string
// cookies map[string]string
h string
cmd string
typ string // GET POST
data string
url string
verbose bool
2019-08-25 01:48:06 +03:00
user_agent string
2019-12-03 13:08:57 +03:00
mut:
user_ptr voidptr
ws_func voidptr
2019-06-22 21:20:28 +03:00
}
2019-10-24 19:44:49 +03:00
pub struct Response {
2019-06-22 21:20:28 +03:00
pub:
2019-07-31 23:10:28 +03:00
text string
2019-10-24 19:44:49 +03:00
headers map[string]string
2019-06-22 21:20:28 +03:00
status_code int
}
2019-07-31 23:10:28 +03:00
pub fn get(url string) ?Response {
2019-07-29 20:18:26 +03:00
req := new_request('GET', url, '') or {
return error(err)
2019-06-22 21:20:28 +03:00
}
2019-10-10 20:24:36 +03:00
res := req.do() or {
return error(err)
}
return res
2019-07-29 20:18:26 +03:00
}
2019-07-31 23:10:28 +03:00
pub fn post(url, data string) ?Response {
req := new_request('POST', url, data) or {
2019-07-29 20:18:26 +03:00
return error(err)
}
2019-10-10 20:24:36 +03:00
res := req.do() or {
return error(err)
}
return res
2019-06-22 21:20:28 +03:00
}
2019-11-18 00:42:25 +03:00
// new_request creates a new HTTP request
2019-07-29 20:18:26 +03:00
pub fn new_request(typ, _url, _data string) ?Request {
if _url == '' {
return error('http.new_request: empty url')
2019-07-29 20:18:26 +03:00
}
2019-06-22 21:20:28 +03:00
mut url := _url
mut data := _data
// req.headers['User-Agent'] = 'V $VERSION'
if typ == 'GET' && !url.contains('?') && data != '' {
url = '$url?$data'
data = ''
}
2019-07-29 20:18:26 +03:00
return Request {
2019-06-22 21:20:28 +03:00
typ: typ
url: url
data: data
2019-06-22 21:20:28 +03:00
ws_func: 0
user_ptr: 0
2019-08-17 02:55:11 +03:00
headers: map[string]string
2019-08-25 01:48:06 +03:00
user_agent: 'v'
2019-06-22 21:20:28 +03:00
}
}
2019-07-31 23:10:28 +03:00
pub fn get_text(url string) string {
2019-10-24 19:44:49 +03:00
resp := get(url) or { return '' }
return resp.text
}
2019-07-31 23:10:28 +03:00
2019-06-22 21:20:28 +03:00
fn (req mut Request) free() {
req.headers.free()
}
fn (resp mut Response) free() {
resp.headers.free()
}
2019-11-18 00:42:25 +03:00
// add_header adds the key and value of an HTTP request header
2019-06-26 18:45:48 +03:00
pub fn (req mut Request) add_header(key, val string) {
2019-06-22 21:20:28 +03:00
req.headers[key] = val
}
2019-09-05 15:46:24 +03:00
pub fn parse_headers(lines []string) map[string]string {
mut headers := map[string]string
for i, line in lines {
if i == 0 {
continue
}
words := line.split(': ')
if words.len != 2 {
continue
}
headers[words[0]] = words[1]
}
return headers
}
2019-11-18 00:42:25 +03:00
// do will send the HTTP request and returns `http.Response` as soon as the response is recevied
pub fn (req &Request) do() ?Response {
if req.typ == 'POST' {
// req.headers << 'Content-Type: application/x-www-form-urlencoded'
}
url := urllib.parse(req.url) or { return error('http.request.do: invalid URL "$req.url"') }
2019-08-21 20:04:06 +03:00
mut rurl := url
mut resp := Response{}
mut no_redirects := 0
2019-08-21 20:04:06 +03:00
for {
if no_redirects == max_redirects { return error('http.request.do: maximum number of redirects reached ($max_redirects)') }
2019-08-25 01:48:06 +03:00
qresp := req.method_and_url_to_response( req.typ, rurl ) or { return error(err) }
2019-08-21 20:04:06 +03:00
resp = qresp
if ! (resp.status_code in [301, 302, 303, 307, 308]) { break }
// follow any redirects
redirect_url := resp.headers['Location']
qrurl := urllib.parse( redirect_url ) or { return error('http.request.do: invalid URL in redirect "$redirect_url"') }
2019-08-21 20:04:06 +03:00
rurl = qrurl
no_redirects++
}
return resp
}
2019-08-25 01:48:06 +03:00
fn (req &Request) method_and_url_to_response(method string, url net_dot_urllib.URL) ?Response {
host_name := url.hostname()
scheme := url.scheme
2019-08-21 20:04:06 +03:00
mut p := url.path.trim_left('/')
mut path := if url.query().size > 0 { '/$p?${url.query().encode()}' } else { '/$p' }
mut nport := url.port().int()
if nport == 0 {
if scheme == 'http' { nport = 80 }
if scheme == 'https' { nport = 443 }
}
//println('fetch $method, $scheme, $host_name, $nport, $path ')
if scheme == 'https' {
//println('ssl_do( $nport, $method, $host_name, $path )')
2019-10-10 20:24:36 +03:00
res := req.ssl_do( nport, method, host_name, path ) or {
return error(err)
}
return res
2019-08-21 20:04:06 +03:00
} else if scheme == 'http' {
//println('http_do( $nport, $method, $host_name, $path )')
2019-10-10 20:24:36 +03:00
res := req.http_do(nport, method, host_name, path ) or {
return error(err)
}
return res
2019-08-21 20:04:06 +03:00
}
return error('http.request.method_and_url_to_response: unsupported scheme: "$scheme"')
2019-08-21 20:04:06 +03:00
}
fn parse_response(resp string) Response {
2019-08-17 02:55:11 +03:00
mut headers := map[string]string
2019-10-24 19:44:49 +03:00
first_header := resp.all_before('\n')
mut status_code := 0
if first_header.contains('HTTP/') {
val := first_header.find_between(' ', ' ')
status_code = val.int()
}
2019-10-24 19:44:49 +03:00
mut text := ''
// Build resp headers map and separate the body
mut nl_pos := 3
mut i := 1
for {
old_pos := nl_pos
nl_pos = resp.index_after('\n', nl_pos+1)
if nl_pos == -1 {
2019-10-24 19:44:49 +03:00
break
}
h := resp[old_pos + 1..nl_pos]
2019-10-24 19:44:49 +03:00
// End of headers
if h.len <= 1 {
text = resp[nl_pos + 1..]
2019-10-24 19:44:49 +03:00
break
}
i++
2019-11-30 15:27:16 +03:00
pos := h.index(':') or {
continue
}
//if h.contains('Content-Type') {
//continue
//}
key := h[..pos]
2019-11-30 15:27:16 +03:00
val := h[pos+2..]
headers[key] = val.trim_space()
2019-08-07 04:57:47 +03:00
}
2019-11-30 15:27:16 +03:00
2019-08-07 04:57:47 +03:00
if headers['Transfer-Encoding'] == 'chunked' {
text = chunked.decode( text )
}
return Response {
2019-10-24 19:44:49 +03:00
status_code: status_code
headers: headers
2019-10-24 19:44:49 +03:00
text: text
}
}
2019-08-25 01:48:06 +03:00
fn (req &Request) build_request_headers(method, host_name, path string) string {
ua := req.user_agent
mut uheaders := []string
2019-11-30 15:27:16 +03:00
for key, val in req.headers {
2019-10-24 19:44:49 +03:00
uheaders << '${key}: ${val}\r\n'
2019-08-25 01:48:06 +03:00
}
if req.data.len > 0 {
uheaders << 'Content-Length: ${req.data.len}\r\n'
}
2019-10-24 19:44:49 +03:00
return '$method $path HTTP/1.1\r\n' +
'Host: $host_name\r\n' +
2019-08-25 01:48:06 +03:00
'User-Agent: $ua\r\n' +
uheaders.join('') +
2019-10-24 19:44:49 +03:00
'Connection: close\r\n\r\n' +
2019-08-25 01:48:06 +03:00
req.data
}
pub fn unescape_url(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.unescape_url() was replaced with urllib.query_unescape()')
}
pub fn escape_url(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.escape_url() was replaced with urllib.query_escape()')
}
pub fn unescape(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.unescape() was replaced with http.unescape_url()')
}
pub fn escape(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.escape() was replaced with http.escape_url()')
}
type wsfn fn (s string, ptr voidptr)