HTTPS: Difference between revisions
m
→{{header|Wren}}: Minor tidy
(Undo vandalism) |
m (→{{header|Wren}}: Minor tidy) |
||
(20 intermediate revisions by 14 users not shown) | |||
Line 9:
{{libheader|AWS}}
Exactly the same as the HTTP task, assuming you compiled AWS with openssl support.
<
with AWS.Client;
with AWS.Response;
Line 18:
URL => "https://sourceforge.net/")));
end GetHttps;
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print read "https://www.w3.org/"</syntaxhighlight>
=={{header|AutoHotkey}}==
{{libheader|wininet}}
<syntaxhighlight lang="autohotkey">
URL := "https://sourceforge.net/"
WININET_Init()
Line 30 ⟶ 34:
#include urlgetcontents.ahk
#include wininet.ahk
</syntaxhighlight>
=={{header|BaCon}}==
This code requires BaCon 3.8.2 or later.
<
website$ = "www.google.com"
Line 49 ⟶ 53:
PRINT REPLACE$(total$, "\r\n[0-9a-fA-F]+\r\n", "\r\n", TRUE) : ' Remove chunk indicators from HTML data
</syntaxhighlight>
=={{header|Batch File}}==
<
:: Must have curl.exe
curl.exe -k -s -L https://sourceforge.net/
</syntaxhighlight>
=={{header|C}}==
{{libheader|libcurl}}
<
#include <stdlib.h>
#include <curl/curl.h>
Line 76 ⟶ 80:
}
return EXIT_SUCCESS;
}</
=={{header|C sharp|C#}}==
{{works with|C sharp|3.0}}
<
using System;
using System.Net;
Line 95 ⟶ 99:
}
}
</syntaxhighlight>
This does not work for urls requiring a secure (SSL) connection.
Line 102 ⟶ 106:
Using the duck-streams as a convenient wrapper for Java's networking classes, grabbing the contents of an HTTPS URL is as easy as:
<
(use '[clojure.contrib.duck-streams :only (slurp*)])
(print (slurp* "https://sourceforge.net"))
</syntaxhighlight>
The usual Java mechanisms can be used to manage acceptance of SSL certificates if required.
{{works with|Clojure|1.2}}
<
(print (slurp "https://sourceforge.net"))
</syntaxhighlight>
=={{header|D}}==
Using curl
<syntaxhighlight lang="d">
import std.stdio;
import std.net.curl;
auto data = get("https://sourceforge.net");
writeln(data);
</syntaxhighlight>
=={{header|Common Lisp}}==
Line 127 ⟶ 133:
First grabbing the entire body as a string, and then by pulling from a stream. This is the same code as in [[HTTP Request]]; <code>drakma:http-request</code> supports SSL.
<
(defun wget-drakma-string (url &optional (out *standard-output*))
"Grab the body as a string, and write it to out."
Line 141 ⟶ 147:
;; Use
(wget-drakma-stream "https://sourceforge.net")
</syntaxhighlight>
{{libheader|Dexador}}
<syntaxhighlight lang="lisp">
(format t "~a~%" (nth-value 0 (dex:get "https://www.w3.org/")))
</syntaxhighlight>
=={{header|Delphi}}==
{{libheader|OpenSSL}}
<syntaxhighlight lang="delphi">
program ShowHTTPS;
Line 166 ⟶ 178:
end;
end.
</syntaxhighlight>
=={{header|EchoLisp}}==
'''file->string''' usage: the server must allow cross-domain access, or a browser add-on like cors-everywhere must be installed to bypass cross-domain checking.
<
;; asynchronous call back definition
(define (success name text) (writeln 'Loaded name) (writeln text))
;;
(file->string success "https:/sourceforge.net")
</syntaxhighlight>
=={{header|Erlang}}==
===Synchronous===
<
-module(main).
-export([main/1]).
Line 190 ⟶ 202:
{error, Res} -> io:fwrite("~p~n", [Res])
end.
</syntaxhighlight>
===Asynchronous===
<
-module(main).
-export([main/1]).
Line 206 ⟶ 218:
after 10000 -> io:fwrite("Timed out.~n",[])
end.
</syntaxhighlight>
Using it
<
|escript ./req.erl https://sourceforge.net/
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
The underlying .NET classes handle secure web connections the same way they manage insecure connections.
<
#light
let wget (url : string) =
let c = new System.Net.WebClient()
c.DownloadString(url)
</syntaxhighlight>
=={{header|Frink}}==
<syntaxhighlight lang="frink">print[read["https://sourceforge.net/"]]</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
local fn GET_HTTPS
CFStringRef response = unix @"curl -ksL https://sourceforge.net/"
CFDataRef dta = fn StringData( response, NSUTF8StringEncoding )
CFDictionaryRef options = @{NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType, NSCharacterEncodingDocumentAttribute: @(NSUTF8StringEncoding)}
CFAttributedStringRef aStr = fn AttributedStringWithHTML( dta, options )
NSLog( @"%@", aStr )
end fn
fn GET_HTTPS
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
We're sorry -- the Sourceforge site is currently in Disaster Recovery mode. Please check back later. {
NSColor = "sRGB IEC61966-2.1 colorspace 0 0 0 1";
NSFont = "\"Times-Roman 12.00 pt. P [] (0x7f8f94e11ce0) fobj=0x7f8f94e0fda0, spc=3.00\"";
NSKern = 0;
NSParagraphStyle = "Alignment 4, LineSpacing 0, ParagraphSpacing 0, ParagraphSpacingBefore 0, HeadIndent 0, TailIndent 0, FirstLineHeadIndent 0, LineHeight 0/0, LineHeightMultiple 0, LineBreakMode 0, Tabs (\n), DefaultTabInterval 36, Blocks (\n), Lists (\n), BaseWritingDirection 0, HyphenationFactor 0, TighteningForTruncation YES, HeaderLevel 0 LineBreakStrategy 0";
NSStrokeColor = "sRGB IEC61966-2.1 colorspace 0 0 0 1";
NSStrokeWidth = 0;
}
</pre>
=={{header|Go}}==
<syntaxhighlight lang="go">
package main
Line 245 ⟶ 283:
io.Copy(os.Stdout, r.Body)
}
</syntaxhighlight>
=={{header|Groovy}}==
<
new URL("https://sourceforge.net").eachLine { println it }
</syntaxhighlight>
=={{header|Haskell}}==
Line 258 ⟶ 296:
This is just the example from [http://hackage.haskell.org/packages/archive/http-conduit/1.8.5.1/doc/html/Network-HTTP-Conduit.html Network.HTTP.Conduit], with the http URL replaced with an https one, since [http://hackage.haskell.org/package/http-conduit http-conduit] natively supports https without needing any additional work.
<
import Network.HTTP.Conduit
Line 265 ⟶ 303:
main = withSocketsDo
$ simpleHttp "https://sourceforge.net/" >>= L.putStr</
==Icon and {{header|Unicon}}==
<
procedure main(arglist)
url := (\arglist[1] | "https://sourceforge.net/")
Line 274 ⟶ 312:
while write(read(w))
close(w)
end</
{{out}}
Line 284 ⟶ 322:
=={{header|Ioke}}==
{{trans|Java}}
<
connection = URL new("https://sourceforge.net") openConnection
scanner = Scanner new(connection getInputStream)
Line 291 ⟶ 329:
scanner next println
)
</syntaxhighlight>
=={{header|J}}==
Using <tt>gethttp</tt> from [[Web Scraping#J|Web Scraping]]
<syntaxhighlight lang="j">
#page=: gethttp'https://sourceforge.net'
0
#page=: '--no-check-certificate' gethttp'https://sourceforge.net'
900
</syntaxhighlight>
(We can not load the example page using https unless we disable certificate checking. The numbers are the number of characters retrieved.)
=={{header|Java}}==
=== javax.net.ssl ===
Additional certificate information is available through the [http://java.sun.com/javase/6/docs/api/javax/net/ssl/HttpsURLConnection.html javax.net.ssl.HttpsURLConnection] interface.
<syntaxhighlight lang="java">
URL url = new URL("https://sourceforge.net");
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
Line 315 ⟶ 354:
System.out.println(scanner.next());
}
</syntaxhighlight>
=== java.net.http ===
Using the standard [http://openjdk.java.net/groups/net/httpclient/ Java 11 HTTP Client]
<syntaxhighlight lang="java">import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.Charset;
public class Main {
public static void main(String[] args) {
var request = HttpRequest.newBuilder(URI.create("https://sourceforge.net"))
.GET()
.build();
HttpClient.newHttpClient()
.sendAsync(request, HttpResponse.BodyHandlers.ofString(Charset.defaultCharset()))
.thenApply(HttpResponse::body)
.thenAccept(System.out::println)
.join();
}
}</syntaxhighlight>
=={{header|JavaScript}}==
=== Browser ===
Using fetch API and async/await:
<syntaxhighlight lang="javascript">
const response = await fetch('https://rosettacode.org');
const text = await response.text();
console.log(text);
</syntaxhighlight>
<syntaxhighlight lang="javascript">fetch("https://sourceforge.net").then(function (response) {
return response.text();
}).then(function (body) {
return body;
});</
=== Node.js ===
<
let body = "";
resp.on("data", function (chunk) {
Line 335 ⟶ 407:
}).on("error", function (err) {
console.error("Error: " + err.message);
});</
=={{header|Julia}}==
<
using Requests
str = readstring(get("https://sourceforge.net/"))</
=={{header|Kotlin}}==
<
import java.net.URL
import javax.net.ssl.HttpsURLConnection
Line 359 ⟶ 431:
while (sc.hasNextLine()) println(sc.nextLine())
sc.close()
}</
Or simplier, since Kotlin 1.2
<
import java.net.URL
Line 368 ⟶ 440:
println(URL("https://sourceforge.net").readText())
}
</syntaxhighlight>
=={{header|Lasso}}==
<
local(y = #x->result)
#y->asString</
If a site with an invalid SSL Cert is encountered the curl type throws the following error:
Line 383 ⟶ 455:
*Windows:
{{libheader|Curl Xtra}}
<
CURLOPT_URL = 10002
ch.setOption(CURLOPT_URL, "https://sourceforge.net")
Line 392 ⟶ 464:
put "Result:" && res.readRawString(res.length)
end if
-- "Result: <!doctype html> ..."</
*Mac OS X:
{{libheader|Shell Xtra}}
<
put sx.shell_cmd("curl https://sourceforge.net")</
=={{header|LiveCode}}==
Blocking version<
get URL "https://sourceforge.net/"</
Non-blocking version, execute getWebResource
<
get URL "https://sourceforge.net/" -- this will now fetch a locally cached copy
put it
Line 412 ⟶ 484:
libURLSetSSLVerification true --check cert
load URL "https://sourceforge.net/" with message "myUrlDownloadFinished"
end getWebResource</
=={{header|LSL}}==
Line 418 ⟶ 490:
To test it yourself; rez a box on the ground, and add the following as a New Script.
<
key kHttpRequestId;
default {
Line 437 ⟶ 509:
}
}
}</
Output:
<pre>Status=200
Line 464 ⟶ 536:
{{works with|Lua|5.1 - 5.3}}
{{libheader|lua-http}}
<
local request = require('http.request')
local headers, stream = request.new_from_uri("https://sourceforge.net/"):go()
Line 470 ⟶ 542:
local status = headers:get(':status')
io.write(string.format('Status: %d\nBody: %s\n', status, body)
</syntaxhighlight>
HTTPS requests can be also done with the much smaller libraries like [[LuaSec]] or [[lua-requests]], but it currently don't support redirects, which is why I used [[lua-http]] in this example.
=={{header|Maple}}==
<syntaxhighlight lang="maple">
content := URL:-Get( "https://www.google.ca/" );
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Straight forward "Import" task. More complicated secure web access can be done using J/Link; essentially a link to Java API.
<syntaxhighlight lang="mathematica">
content=Import["https://sourceforge.net", "HTML"]
</syntaxhighlight>
=={{header|MATLAB}} / {{header|Octave}}==
<
=={{header|Nemerle}}==
This example is essentially identical to the [[HTTP]] task because the <tt>WebClient</tt> object can be used with http:, https:, ftp: and file: uri's.
<
using System.Console;
using System.Net;
Line 505 ⟶ 577:
myStream.Close()
}
}</
=={{header|NewLISP}}==
<
=={{header|Nim}}==
{{libheader|OpenSSL}}
Compile with <code>nim c -d:ssl httpsClient.nim</code>:
<
var client = newHttpClient()
echo client.getContent("https://sourceforge.net")</
=={{header|Objeck}}==
<
use HTTP;
Line 531 ⟶ 603:
}
}
</syntaxhighlight>
=={{header|Ol}}==
{{libheader|libcurl}}
<syntaxhighlight lang="scheme">
(import (lib curl))
(define curl (make-curl))
(curl 'url "https://www.w3.org/")
(curl 'perform)
</syntaxhighlight>
=={{header|Pascal}}==
{{works with|Free Pascal}}
Using [http://wiki.freepascal.org/fphttpclient fphttpclient]
<
uses fphttpclient;
Line 551 ⟶ 634:
end;
writeln(s)
end.</
=={{header|Perl}}==
{{libheader|LWP}}
<
use strict;
use LWP::UserAgent;
Line 565 ⟶ 648:
print $response->as_string;
</syntaxhighlight>
=={{header|Phix}}==
{{libheader|Phix/libcurl}}
Exactly the same as the [[HTTP#Phix]] task.
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">libcurl</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #7060A8;">curl_global_init</span><span style="color: #0000FF;">()</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">curl</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">curl_easy_init</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">curl_easy_setopt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curl</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CURLOPT_URL</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"https://sourceforge.net/"</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">object</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">curl_easy_perform_ex</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curl</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">curl_easy_cleanup</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curl</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">curl_global_cleanup</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
=={{header|PHP}}==
<
echo file_get_contents('https://sourceforge.net');
</syntaxhighlight>
=={{header|PicoLisp}}==
PicoLisp has no functionality for communicating with a HTTPS server
(only for the other direction), but it is easy to use an external tool
<syntaxhighlight lang="picolisp">
(in '(curl "https://sourceforge.net") # Open a pipe to 'curl'
(out NIL (echo)) ) # Echo to standard output
</syntaxhighlight>
=={{header|Pike}}==
<
int main() {
write("%s\n", Protocols.HTTP.get_url_data("https://sourceforge.net"));
}
</syntaxhighlight>
=={{header|PowerShell}}==
<
Invoke-WebRequest 'https://www.rosettacode.org'
</syntaxhighlight>
<syntaxhighlight lang="powershell">
$wc = New-Object Net.WebClient
$wc.DownloadString('https://sourceforge.net')
</syntaxhighlight>
If the certificate could not be validated (untrusted, self-signed, expired), then an Exception is thrown with the message ''“The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel.”'' so certificate validation is done automatically by the method.
Line 610 ⟶ 700:
=={{header|Python}}==
Python's '''urllib.request''' library, has support for SSL if the interpreter's underlying ''httplib'' libraries were compiled with SSL support. By default this will be the enabled for default Python installations on most platforms.
<
print(urllib.request.urlopen("https://sourceforge.net/").read())</
=={{header|R}}==
Line 618 ⟶ 708:
The basic idea is to use getURL (as with [[HTTP_Request]]), but with some extra parameters.
<
webpage <- getURL("https://sourceforge.net/", .opts=list(followlocation=TRUE, ssl.verifyhost=FALSE, ssl.verifypeer=FALSE))</
In this case, the webpage output contains unprocessed characters, e.g. \" instead of " and \\ instead of \, so we need to process the markup.
<syntaxhighlight lang="r">
wp <- readLines(tc <- textConnection(webpage))
close(tc)
</syntaxhighlight>
Finally, we parse the HTML and find the interesting bit.
<syntaxhighlight lang="r">
pagetree <- htmlTreeParse(wp)
pagetree$children$html
</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(require net/url)
Line 641 ⟶ 731:
#:redirections 100)
(current-output-port))
</syntaxhighlight>
=={{header|Raku}}==
Line 648 ⟶ 738:
There are several modules that provide HTTPS capability. WWW and HTTP::UserAgent are probably the most popular right now, but others exist.
<syntaxhighlight lang="raku"
say get 'https://sourceforge.net/';</
or
<syntaxhighlight lang="raku"
say HTTP::UserAgent.new.get('https://sourceforge.net/').content;</
=={{header|REALbasic}}==
REALBasic provides an HTTPSecureSocket class for handling HTTPS connections. The 'Get' method of the HTTPSecureSocket is overloaded and can download data to a file or return data as a string, in both cases an optional timeout argument can be passed.
<syntaxhighlight lang="realbasic">
Dim sock As New HTTPSecureSocket
Print(sock.Get("https://sourceforge.net", 10)) //set the timeout period to 10 seconds.
</syntaxhighlight>
=={{header|Ring}}==
<
cStr= download("http://sourceforge.net/")
see cStr + nl
</syntaxhighlight>
=={{header|RLaB}}==
Line 674 ⟶ 764:
This solution doesn't use the <code>open-uri</code> convenience package that the [[HTTP Request#Ruby]] solution uses: the <code>Net::HTTP</code> object must be told to use SSL before the session is started.
<
require 'net/https'
require 'uri'
Line 690 ⟶ 780:
puts content.body
end
</syntaxhighlight>
outputs
Line 715 ⟶ 805:
</body>
</html>
</pre>
=={{header|Rust}}==
<syntaxhighlight lang="rust">
extern crate reqwest;
fn main() {
let response = match reqwest::blocking::get("https://sourceforge.net") {
Ok(response) => response,
Err(e) => panic!("error encountered while making request: {:?}", e),
};
println!("{}", response.text().unwrap());
}
</syntaxhighlight>
{{out}}
<pre>
<!-- Server: sfs-consume-7 -->
<html class="no-js" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no" />
<script>
var __gdpr = true;
var __ccpa = false;
...
</pre>
=={{header|Scala}}==
{{libheader|Scala}}
<
object HttpsTest extends App {
Line 725 ⟶ 843:
Source.fromURL("https://sourceforge.net").getLines.foreach(println)
}</
=={{header|Seed7}}==
Line 732 ⟶ 850:
HTTPS protocol go get a file.
<
include "gethttps.s7i";
include "utf8.s7i";
Line 739 ⟶ 857:
begin
writeln(STD_UTF8_OUT, getHttps("sourceforge.net"));
end func;</
=={{header|Sidef}}==
<syntaxhighlight lang
require('LWP::Protocol::https')
func get(url) {
static ua = %O<LWP::UserAgent>.new(
agent => 'Mozilla/5.0',
ssl_opts => Hash(verify_hostname => 1),
)
var resp = ua.get(url)
if (resp.is_success) {
return resp.decoded_content
}
die "Failed to GET #{url}: #{resp.status_line}"
}
say get("https://rosettacode.org")</syntaxhighlight>
=={{header|Swift}}==
<
// With https
Line 769 ⟶ 892:
}
CFRunLoopRun() // dispatch</
=={{header|Tcl}}==
Though Tcl's built-in <code>http</code> package does not understand SSL, it does support the registration of external handlers to accommodate additional protocols. This allows the use of the [http://tls.sourceforge.net/ Tls] package to supply the missing functionality with only a single line to complete the registration.
<
package require http
package require tls
Line 791 ⟶ 914:
puts [http::data $token]
http::cleanup $token
</syntaxhighlight>
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
SET DATEN = REQUEST ("https://sourceforge.net")
*{daten}
</syntaxhighlight>
=={{header|UNIX Shell}}==
<
curl -k -s -L https://sourceforge.net/
</syntaxhighlight>
=={{header|VBScript}}==
Line 809 ⟶ 932:
Based on code at [http://itknowledgeexchange.techtarget.com/vbscript-systems-administrator/how-to-retrieve-html-web-pages-with-vbscript-via-the-microsoftxmlhttp-object/ How to retrieve HTML web pages with VBScript via the Microsoft.XmlHttp object]
<syntaxhighlight lang="vb">
Option Explicit
Line 827 ⟶ 950:
Set oHTTP = Nothing
</syntaxhighlight>
=={{header|Visual Basic}}==
Line 836 ⟶ 959:
{{works with|VBA|6.5}}
{{works with|VBA|7.1}}
<
Dim HttpReq As WinHttp.WinHttpRequest
' in the "references" dialog of the IDE, check
Line 856 ⟶ 979:
HttpReq.Send
Debug.Print HttpReq.ResponseText
End Sub</
=={{header|Visual Basic .NET}}==
<
Imports System.Net
Line 865 ⟶ 988:
Dim content As String = client.DownloadString("https://sourceforge.net")
Console.WriteLine(content)
</syntaxhighlight>
=={{header|Wren}}==
{{trans|C}}
{{libheader|libcurl}}
An embedded program so we can ask the C host to communicate with libcurl for us.
<syntaxhighlight lang="wren">/* HTTPS.wren */
var CURLOPT_URL = 10002
var CURLOPT_FOLLOWLOCATION = 52
var CURLOPT_ERRORBUFFER = 10010
foreign class Curl {
construct easyInit() {}
foreign easySetOpt(opt, param)
foreign easyPerform()
foreign easyCleanup()
}
var curl = Curl.easyInit()
if (curl == 0) {
System.print("Error initializing cURL.")
return
}
curl.easySetOpt(CURLOPT_URL, "https://www.w3.org/")
curl.easySetOpt(CURLOPT_FOLLOWLOCATION, 1)
curl.easySetOpt(CURLOPT_ERRORBUFFER, 0) // buffer to be supplied by C
var status = curl.easyPerform()
if (status != 0) {
System.print("Failed to perform task.")
return
}
curl.easyCleanup()</syntaxhighlight>
<br>
We now embed this in the following C program, compile and run it.
<syntaxhighlight lang="c">/* gcc HTTPS.c -o HTTPS -lcurl -lwren -lm */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include "wren.h"
/* C <=> Wren interface functions */
void C_curlAllocate(WrenVM* vm) {
CURL** pcurl = (CURL**)wrenSetSlotNewForeign(vm, 0, 0, sizeof(CURL*));
*pcurl = curl_easy_init();
}
void C_easyPerform(WrenVM* vm) {
CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);
CURLcode cc = curl_easy_perform(curl);
wrenSetSlotDouble(vm, 0, (double)cc);
}
void C_easyCleanup(WrenVM* vm) {
CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);
curl_easy_cleanup(curl);
}
void C_easySetOpt(WrenVM* vm) {
CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);
CURLoption opt = (CURLoption)wrenGetSlotDouble(vm, 1);
if (opt < 10000) {
long lparam = (long)wrenGetSlotDouble(vm, 2);
curl_easy_setopt(curl, opt, lparam);
} else {
if (opt == CURLOPT_URL) {
const char *url = wrenGetSlotString(vm, 2);
curl_easy_setopt(curl, opt, url);
} else if (opt == CURLOPT_ERRORBUFFER) {
char buffer[CURL_ERROR_SIZE];
curl_easy_setopt(curl, opt, buffer);
}
}
}
WrenForeignClassMethods bindForeignClass(WrenVM* vm, const char* module, const char* className) {
WrenForeignClassMethods methods;
methods.allocate = NULL;
methods.finalize = NULL;
if (strcmp(module, "main") == 0) {
if (strcmp(className, "Curl") == 0) {
methods.allocate = C_curlAllocate;
}
}
return methods;
}
WrenForeignMethodFn bindForeignMethod(
WrenVM* vm,
const char* module,
const char* className,
bool isStatic,
const char* signature) {
if (strcmp(module, "main") == 0) {
if (strcmp(className, "Curl") == 0) {
if (!isStatic && strcmp(signature, "easySetOpt(_,_)") == 0) return C_easySetOpt;
if (!isStatic && strcmp(signature, "easyPerform()") == 0) return C_easyPerform;
if (!isStatic && strcmp(signature, "easyCleanup()") == 0) return C_easyCleanup;
}
}
return NULL;
}
static void writeFn(WrenVM* vm, const char* text) {
printf("%s", text);
}
void errorFn(WrenVM* vm, WrenErrorType errorType, const char* module, const int line, const char* msg) {
switch (errorType) {
case WREN_ERROR_COMPILE:
printf("[%s line %d] [Error] %s\n", module, line, msg);
break;
case WREN_ERROR_STACK_TRACE:
printf("[%s line %d] in %s\n", module, line, msg);
break;
case WREN_ERROR_RUNTIME:
printf("[Runtime Error] %s\n", msg);
break;
}
}
char *readFile(const char *fileName) {
FILE *f = fopen(fileName, "r");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
rewind(f);
char *script = malloc(fsize + 1);
fread(script, 1, fsize, f);
fclose(f);
script[fsize] = 0;
return script;
}
int main(int argc, char **argv) {
WrenConfiguration config;
wrenInitConfiguration(&config);
config.writeFn = &writeFn;
config.errorFn = &errorFn;
config.bindForeignClassFn = &bindForeignClass;
config.bindForeignMethodFn = &bindForeignMethod;
WrenVM* vm = wrenNewVM(&config);
const char* module = "main";
const char* fileName = "HTTPS.wren";
char *script = readFile(fileName);
WrenInterpretResult result = wrenInterpret(vm, module, script);
switch (result) {
case WREN_RESULT_COMPILE_ERROR:
printf("Compile Error!\n");
break;
case WREN_RESULT_RUNTIME_ERROR:
printf("Runtime Error!\n");
break;
case WREN_RESULT_SUCCESS:
break;
}
wrenFreeVM(vm);
free(script);
return 0;
}</syntaxhighlight>
=={{header|zkl}}==
Using the cURL library to do the heavy lifting:
<
zkl: var data=ZC().get("https://sourceforge.net")
L(Data(36,265),826,0)</
get returns the text of the response along with two counts: the bytes of header in front of the html code and the byte count of stuff after the end of the page. So, if you wanted to look at the header:
<pre>zkl: data[0][0,data[1]).text
Line 894 ⟶ 1,182:
{{omit from|Brainf***}}
{{omit from|Commodore BASIC|Does not have network access}}
{{omit from|EasyLang|Has no internet functions}}
{{omit from|Inform 7|Does not have network access.}}
{{omit from|Integer BASIC|No TCP/IP network support on Apple II}}
|