mirror of
https://git.sr.ht/~crc_/retroforth
synced 2024-11-16 19:48:56 +01:00
112 lines
3.3 KiB
Text
112 lines
3.3 KiB
Text
Typically to deal with HTTP I just use curl(1), but it is possible to
|
|
make HTTP requests using the sockets vocabulary. It's just a pain to
|
|
do so as HTTP has a lot of annoyances.
|
|
|
|
This example provides a way to make HTTP requests using only RETRO.
|
|
|
|
First, some variables. I'll keep the socket handle in `Socket` and the
|
|
number of bytes read in `Read`.
|
|
|
|
~~~
|
|
'Socket var
|
|
'Read var
|
|
~~~
|
|
|
|
Since HTTP allows for a large number of response headers with various
|
|
sizes and ordering, skipping them can be annoying. I do care about one:
|
|
the Content-Length: result.
|
|
|
|
I'll track the number of sequential newlines in a variable named `Seq`,
|
|
the value for Content-Length in `Length`, and then the current response
|
|
line in `Line`.
|
|
|
|
As a bonus annoyance, HTTP doesn't limit the size of any particular
|
|
header line, so I need to allocate enough space to cover anything it
|
|
throws at me. Per a stackoverflow posting at
|
|
https://stackoverflow.com/questions/686217/maximum-on-http-header-values
|
|
I'll need at least 8KiB, so:
|
|
|
|
~~~
|
|
'Length var
|
|
'Seq var
|
|
'Line var #8192 allot
|
|
~~~
|
|
|
|
Then skipping the headers is a matter of reading lines until two newlines
|
|
are encountered.
|
|
|
|
~~~
|
|
:read-byte here #1 @Socket socket:recv drop-pair here fetch ;
|
|
:append dup buffer:add ;
|
|
:eol? [ ASCII:LF eq? ] [ ASCII:CR eq? ] bi or ;
|
|
:is-length? &Line 'Content-Length:_ s:begins-with? ;
|
|
:process &Line s:trim #16 + s:to-number !Length ;
|
|
:next &Line buffer:set ;
|
|
:yes &Seq v:inc ;
|
|
:no #0 !Seq ;
|
|
:check [ yes is-length? [ process ] if next ] [ no ] choose ;
|
|
:read-line read-byte append eol? check ;
|
|
:done? @Seq #4 eq? ;
|
|
:skip-headers [ &Line buffer:set [ read-line done? ] until ] buffer:preserve ;
|
|
~~~
|
|
|
|
Now on to making the actual request to the server. An HTTP PUT request
|
|
takes a form like:
|
|
|
|
POST <file> HTTP/1.1
|
|
Host: domain
|
|
Content-Type: text/plain
|
|
Content-Length: <size>
|
|
|
|
<parameters>
|
|
|
|
So I begin by writing a word to parse a URL. It'll store pointers to the
|
|
parts in the `Host` and `Request` variables. This is pretty easy. I
|
|
increase the starting point by 7 to skip over the HTTP:// part and then
|
|
split on the first / character to separate the domain and requested file.
|
|
This also takes a second string with the parameters to pass.
|
|
|
|
~~~
|
|
'Host var
|
|
'Request var
|
|
'Params var
|
|
|
|
:parse-url #7 + $/ s:split s:keep !Host s:keep !Request s:keep !Params ;
|
|
~~~
|
|
|
|
Given that, making a request is simply:
|
|
|
|
~~~
|
|
:make-request
|
|
@Params dup s:length @Host @Request
|
|
'POST_%s_HTTP/1.1\r\nHost:_%s\r\nContent-Type:_text/plain\r\nContent-Length:_%n\r\n\r\n%s\r\n s:format @Socket socket:send drop-pair ;
|
|
~~~
|
|
|
|
Moving on to reading the body, this is just reading bytes and shoving
|
|
them into a buffer. I use the `Read` variable to track the number of
|
|
bytes read, stopping when this reaches the `Length` extracted from the
|
|
headers.
|
|
|
|
~~~
|
|
:read-byte here #1 @Socket socket:recv drop-pair here fetch buffer:add ;
|
|
:read-body [ &Read v:inc read-byte @Read @Length eq? ] until ;
|
|
~~~
|
|
|
|
And finally tieing this all together:
|
|
|
|
~~~
|
|
:http:post (ass-n)
|
|
parse-url
|
|
#0 !Seq #0 !Read
|
|
socket:create !Socket @Host '80 socket:configure
|
|
@Socket socket:connect drop-pair
|
|
[ buffer:set make-request skip-headers read-body ] buffer:preserve @Read ;
|
|
~~~
|
|
|
|
And a test case:
|
|
|
|
```
|
|
'Body d:create #90000 allot
|
|
&Body 'hand=wave&test=true 'http://httpbin.org/post http:post
|
|
&Body s:put
|
|
```
|