Data commit

Task/HTTPS-Authenticated/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/HTTPS/Authenticated
+note: Networking and Web Interaction

Task/HTTPS-Authenticated/00-TASK.txt

@@ -0,0 +1,3 @@
+The goal of this task is to demonstrate [[HTTPS request]]s with authentication.
+Implementations of this task should not use client certificates for this: that is the subject of [[Client-Authenticated HTTPS Request|another task]].
+

Task/HTTPS-Authenticated/Arturo/https-authenticated.arturo

@@ -0,0 +1,6 @@
+user: "admin"
+pass: "admin"
+
+inspect request.headers:#[
+    Authorization: "Basic " ++ encode user ++ ":" ++ pass
+] "https://httpbin.org/basic-auth/admin/admin" ø

Task/HTTPS-Authenticated/AutoHotkey/https-authenticated.ahk

@@ -0,0 +1,15 @@
+iWeb_Init()
+pwb := iWeb_newGui(0, 0, 1000, 800)
+iWeb_nav(pwb, "http://www.facebook.com/login.php?ref=pf")
+iWeb_Term()
+iWeb_complete(pwb)
+inputbox, email, email
+inputbox, pass, password
+iWeb_setDomObj(pwb,"Email",email)
+iWeb_setDomObj(pwb,"pass",pass)
+iWeb_clickDomObj(pwb, "login")
+return
+
+#Include iweb.ahk
+#Include COM.ahk
+#Include COMinvokeDeep.ahk

Task/HTTPS-Authenticated/BaCon/https-authenticated.bacon

@@ -0,0 +1,17 @@
+OPTION TLS TRUE
+
+website$ = "website.com"
+username$ = "nobody"
+password$ = "ignore"
+
+OPEN website$ & ":443" FOR NETWORK AS conn
+SEND "GET / HTTP/1.1\r\nHost: " & website$ & "\r\nAuthorization: Basic " & B64ENC$(username$ & ":" & password$) & "\r\n\r\n" TO conn
+
+WHILE WAIT(conn, 2000)
+    RECEIVE data$ FROM conn
+    total$ = total$ & data$
+    IF INSTR(data$, "</html>") THEN BREAK
+WEND
+CLOSE NETWORK conn
+
+PRINT total$

Task/HTTPS-Authenticated/C-sharp/https-authenticated.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Net;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        var client = new WebClient();
+
+        // credentials of current user:
+        client.Credentials = CredentialCache.DefaultCredentials;
+        // or specify credentials manually:
+        client.Credentials = new NetworkCredential("User", "Password");
+
+        var data = client.DownloadString("https://example.com");
+
+        Console.WriteLine(data);
+    }
+}

Task/HTTPS-Authenticated/C/https-authenticated.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "curl/curl.h"
+
+int
+main(void)
+{
+        CURL *curl;
+        char buffer[CURL_ERROR_SIZE];
+
+        if ((curl = curl_easy_init()) != NULL) {
+                curl_easy_setopt(curl, CURLOPT_URL, "https://user:password@secure.example.com/");
+                curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
+                curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, buffer);
+                if (curl_easy_perform(curl) != CURLE_OK) {
+                        fprintf(stderr, "%s\n", buffer);
+                        return EXIT_FAILURE;
+                }
+                curl_easy_cleanup(curl);
+        }
+        return EXIT_SUCCESS;
+}

Task/HTTPS-Authenticated/Clojure/https-authenticated.clj

@@ -0,0 +1,2 @@
+(clj-http.client/get "https://somedomain.com"
+                     {:basic-auth ["user" "pass"]})

Task/HTTPS-Authenticated/Delphi/https-authenticated.delphi

@@ -0,0 +1,26 @@
+program ShowHTTPSAuthenticated;
+
+{$APPTYPE CONSOLE}
+
+uses IdHttp, IdSSLOpenSSL;
+
+var
+  s: string;
+  lHTTP: TIdHTTP;
+  lIOHandler: TIdSSLIOHandlerSocketOpenSSL;
+begin
+  ReportMemoryLeaksOnShutdown := True;
+  lHTTP := TIdHTTP.Create(nil);
+  lIOHandler := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
+  try
+    lHTTP.Request.Username := 'USERNAME';
+    lHTTP.Request.Password := 'PASSWD';
+    lHTTP.IOHandler := lIOHandler;
+    lHTTP.HandleRedirects := True;
+    s := lHTTP.Get('https://SomeSecureSite.net/');
+    Writeln(s);
+  finally
+    lHTTP.Free;
+    lIOHandler.Free;
+  end;
+end.

Task/HTTPS-Authenticated/Go/https-authenticated-1.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+    "encoding/base64"
+    "io"
+    "log"
+    "net/http"
+    "strings"
+)
+
+const userPass = "rosetta:code"
+const unauth = http.StatusUnauthorized
+
+func hw(w http.ResponseWriter, req *http.Request) {
+    auth := req.Header.Get("Authorization")
+    if !strings.HasPrefix(auth, "Basic ") {
+        log.Print("Invalid authorization:", auth)
+        http.Error(w, http.StatusText(unauth), unauth)
+        return
+    }
+    up, err := base64.StdEncoding.DecodeString(auth[6:])
+    if err != nil {
+        log.Print("authorization decode error:", err)
+        http.Error(w, http.StatusText(unauth), unauth)
+        return
+    }
+    if string(up) != userPass {
+        log.Print("invalid username:password:", string(up))
+        http.Error(w, http.StatusText(unauth), unauth)
+        return
+    }
+    io.WriteString(w, "Goodbye, World!")
+}
+
+func main() {
+    http.HandleFunc("/", hw)
+    log.Fatal(http.ListenAndServeTLS(":8080", "cert.pem", "key.pem", nil))
+}

Task/HTTPS-Authenticated/Go/https-authenticated-2.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+    "crypto/tls"
+    "crypto/x509"
+    "fmt"
+    "io/ioutil"
+    "log"
+    "net/http"
+)
+
+const (
+    userid   = "rosetta"
+    password = "code"
+)
+
+func main() {
+    // Use custom certificate for testing.  Not exactly required by task.
+    b, err := ioutil.ReadFile("cert.pem")
+    if err != nil {
+        log.Fatal(err)
+    }
+    pool := x509.NewCertPool()
+    if ok := pool.AppendCertsFromPEM(b); !ok {
+        log.Fatal("Failed to append cert")
+    }
+    tc := &tls.Config{RootCAs: pool}
+    tr := &http.Transport{TLSClientConfig: tc}
+    client := &http.Client{Transport: tr}
+    req, err := http.NewRequest("GET", "https://127.0.0.1:8080", nil)
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    // This one line implements the authentication required for the task.
+    req.SetBasicAuth(userid, password)
+
+    // Make request and show output.
+    resp, err := client.Do(req)
+    if err != nil {
+        log.Fatal(err)
+    }
+    b, err = ioutil.ReadAll(resp.Body)
+    resp.Body.Close()
+    if err != nil {
+        log.Fatal(err)
+    }
+    fmt.Println(string(b))
+}

Task/HTTPS-Authenticated/Haskell/https-authenticated.hs

@@ -0,0 +1,27 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Main (main) where
+
+import           Data.Aeson (Value)
+import           Data.Default.Class (def)
+import           Network.HTTP.Req
+                    ( (/:)
+                    , GET(..)
+                    , NoReqBody(..)
+                    , basicAuth
+                    , https
+                    , jsonResponse
+                    , req
+                    , responseBody
+                    , runReq
+                    )
+
+main :: IO ()
+main = do
+    response <- runReq def $ req
+            GET
+            (https "httpbin.org" /: "basic-auth" /: "someuser" /: "somepassword")
+            NoReqBody
+            jsonResponse
+            (basicAuth "someuser" "somepassword")
+    print (responseBody response :: Value)

Task/HTTPS-Authenticated/Julia/https-authenticated.julia

@@ -0,0 +1,13 @@
+using HTTP, HTTP.IOExtras, JSON, MusicProcessing
+HTTP.open("POST", "http://music.com/play") do io
+    write(io, JSON.json([
+        "auth" => "12345XXXX",
+        "song_id" => 7,
+    ]))
+    r = startread(io)
+    @show r.status
+    while !eof(io)
+        bytes = readavailable(io)
+        play(bytes)
+    end
+end

Task/HTTPS-Authenticated/Kotlin/https-authenticated.kotlin

@@ -0,0 +1,28 @@
+// version 1.2.0
+
+import java.net.Authenticator
+import java.net.PasswordAuthentication
+import javax.net.ssl.HttpsURLConnection
+import java.net.URL
+import java.io.InputStreamReader
+import java.io.BufferedReader
+
+object PasswordAuthenticator : Authenticator() {
+    override fun getPasswordAuthentication() =
+        PasswordAuthentication ("username", "password".toCharArray())
+}
+
+fun main(args: Array<String>) {
+    val url = URL("https://somehost.com")
+    val con = url.openConnection() as HttpsURLConnection
+    Authenticator.setDefault(PasswordAuthenticator)
+    con.allowUserInteraction = true
+    con.connect()
+    val isr = InputStreamReader(con.inputStream)
+    val br = BufferedReader(isr)
+    while (true) {
+        val line = br.readLine()
+        if (line == null) break
+        println(line)
+    }
+}

Task/HTTPS-Authenticated/Lasso/https-authenticated.lasso

@@ -0,0 +1,5 @@
+local(username = 'hello',password = 'world')
+local(x = curl('https://sourceforge.net'))
+#x->set(CURLOPT_USERPWD, #username + ':' + #password)
+local(y = #x->result)
+#y->asString

Task/HTTPS-Authenticated/LiveCode/https-authenticated-1.livecode

@@ -0,0 +1,6 @@
+command getAuthWebResource
+    libURLFollowHttpRedirects true
+    libURLSetSSLVerification true
+    put URL "https://user:passwd@example.basicauth.com/" into response
+    put response
+end getAuthWebResource

Task/HTTPS-Authenticated/LiveCode/https-authenticated-2.livecode

@@ -0,0 +1,7 @@
+command getAuthWebResource
+    libURLFollowHttpRedirects true
+    libURLSetSSLVerification true
+    set the httpHeaders to "Authorization: Basic " && base64Encode("user:passwd")
+    put URL "https://example.basicauth.com" into response
+    put response
+end getAuthWebResource

Task/HTTPS-Authenticated/Lua/https-authenticated.lua

@@ -0,0 +1,7 @@
+local requests = require('requests')
+local auth = requests.HTTPBasicAuth('admin', 'admin')
+local resp, e = requests.get({
+  url = 'https://httpbin.org/basic-auth/admin/admin',
+  auth = auth
+})
+io.write(string.format('Status: %d', resp.status_code))

Task/HTTPS-Authenticated/Mathematica/https-authenticated.math

@@ -0,0 +1,2 @@
+a = RunThrough["curl -u JohnDoe:Password https://www.example.com", 1]
+For[ i=0, i < Length[a] , i++, SomeFunction[a]]

Task/HTTPS-Authenticated/Nim/https-authenticated.nim

@@ -0,0 +1,9 @@
+import httpclient, base64
+
+const
+  User = "admin"
+  Password = "admin"
+
+let headers = newHttpHeaders({"Authorization": "Basic " & base64.encode(User & ":" & Password)})
+let client = newHttpClient(headers = headers)
+echo client.getContent("https://httpbin.org/basic-auth/admin/admin")

Task/HTTPS-Authenticated/Perl/https-authenticated.pl

@@ -0,0 +1,19 @@
+use LWP::UserAgent qw();
+my $ua = LWP::UserAgent->new;
+my $netloc = 'http://www.buddhism-dict.net/cgi-bin/xpr-dealt.pl:80';
+$ua->credentials(
+   $netloc,
+   'CJK-E and Buddhist Dictionaries', # basic realm
+   'guest',  # user
+   '',       # empty pw
+);
+my $response = $ua->get($netloc);
+
+use WWW::Mechanize qw();
+my $mech = WWW::Mechanize->new;
+$mech->get('https://login.yahoo.com/');
+$mech->submit_form(with_fields => {
+    login         => 'XXXXXX',
+    passwd        => 'YYYYYY',
+    '.persistent' => 'y',  # tick checkbox
+});

Task/HTTPS-Authenticated/Phix/https-authenticated.phix

@@ -0,0 +1,12 @@
+(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://user:password@example.com/"</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>
+<!--

Task/HTTPS-Authenticated/PicoLisp/https-authenticated.l

@@ -0,0 +1,4 @@
+(let (User "Bill"  Pass "T0p5ecRet"  Url "https://www.example.com")
+   (in (list 'curl "-u" (pack User ': Pass) Url)
+      (while (line)
+         (doSomeProcessingWithLine @) ) ) )

Task/HTTPS-Authenticated/PowerShell/https-authenticated.psh

@@ -0,0 +1,7 @@
+$client = [Net.WebClient]::new()
+# credentials of current user:
+$client.Credentials = [Net.CredentialCache]::DefaultCredentials
+# or specify credentials manually:
+# $client.Credentials = [System.Net.NetworkCredential]::new("User", "Password")
+$data = $client.DownloadString("https://example.com")
+Write-Host $data

Task/HTTPS-Authenticated/Python/https-authenticated-1.py

@@ -0,0 +1,24 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from mechanize import Browser
+
+USER_AGENT = "Mozilla/5.0 (X11; U; Linux i686; tr-TR; rv:1.8.1.9) Gecko/20071102 Pardus/2007 Firefox/2.0.0.9"
+
+br = Browser()
+br.addheaders = [("User-agent", USER_AGENT)]
+
+# remove comment if you get debug output
+# br.set_debug_redirects(True)
+# br.set_debug_responses(True)
+# br.set_debug_http(True)
+
+br.open("https://www.facebook.com")
+
+br.select_form("loginform")
+br['email'] = "xxxxxxx@xxxxx.com"
+br['pass'] = "xxxxxxxxx"
+br['persistent'] = ["1"]
+
+response = br.submit()
+print response.read()

Task/HTTPS-Authenticated/Python/https-authenticated-2.py

@@ -0,0 +1,9 @@
+import requests
+
+username = "user"
+password = "pass"
+url = "https://www.example.com"
+
+response = requests.get(url, auth=(username, password)
+
+print(response.text)

Task/HTTPS-Authenticated/Racket/https-authenticated.rkt

@@ -0,0 +1,20 @@
+#lang racket
+
+(require net/url net/url-connect openssl)
+
+(module+ main
+  (parameterize ([current-https-protocol (ssl-make-client-context)])
+    (ssl-set-verify! (current-https-protocol) #t)
+
+    ;; When this is #f, we correctly get an exception:
+    ;; error:14090086:SSL routines:SSL3_GET_SERVER_CERTIFICATE:certificate verify failed
+    (when #t
+      (ssl-load-verify-source! (current-https-protocol)
+                               '(directory
+                                 ;; This location works on Debian 6;
+                                 ;; adjust as needed for your platform.
+                                 "/etc/ssl/certs"
+                                 )))
+
+    (for ([l (in-port read-line (get-pure-port (string->url "https://www.google.com/")))])
+      (displayln  l))))

Task/HTTPS-Authenticated/Raku/https-authenticated.raku

@@ -0,0 +1,10 @@
+use HTTP::UserAgent;
+
+my $username = 'username'; # my username
+my $password = 'password'; # my password
+my $address  = 'http://192.168.1.1/Status_Router.asp'; # my local wireless router
+
+my $ua = HTTP::UserAgent.new;
+$ua.auth( $username, $password );
+my $response = $ua.get: $address;
+say $response.is-success ?? $response.content !! $response.status-line;

Task/HTTPS-Authenticated/Ruby/https-authenticated.rb

@@ -0,0 +1,9 @@
+require 'uri'
+require 'net/http'
+
+uri = URI.parse('https://www.example.com')
+response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+  request = Net::HTTP::Get.new uri
+  request.basic_auth('username', 'password')
+  http.request request
+end

Task/HTTPS-Authenticated/Run-BASIC/https-authenticated.basic

@@ -0,0 +1,32 @@
+html "
+<CENTER><TABLE CELLPADDING=0 CELLSPACING=0 border=1 bgcolor=wheat>
+<TR><TD colspan=2 bgcolor=tan align=center>LOGIN</TD></TR>
+<TR><TD align=right>UserName</TD><TD>"
+ TEXTBOX #userName, ""
+html "</TR></TD><TR><TD align=right>Password:</TD><TD>"
+PasswordBox  #passWord, ""
+
+html "</TD></TR><TD align=center colspan=2>"
+button #si, "Signin", [doSignin]
+html "   "
+button #ex, "Exit", [exit]
+html "</TD></TR></TABLE>"
+WAIT
+
+[doSignin]
+loginUserName$    = trim$(#userName contents$())
+loginPassWord$    = trim$(#passWord contents$())
+if (loginUserName$ = "admin" and loginPassWord$ = "admin" then
+   print "Login ok"
+  else
+   print "invalid User or Pass"
+   cls
+   goto [loop]
+end if
+
+print Platform$    ' OS where Run BASIC is being hosted
+print UserInfo$    ' Information about the user's web browser
+print UserAddress$ ' IP address of the user
+
+[exit]
+end

Task/HTTPS-Authenticated/Rust/https-authenticated.rust

@@ -0,0 +1,20 @@
+extern crate reqwest;
+
+use reqwest::blocking::Client;
+use reqwest::header::CONNECTION;
+
+fn main() {
+    let client = Client::new();
+
+    // reqwest uses strongly-typed structs for creating headers
+    let res = client
+        .get("https://www.example.com")
+        .basic_auth("user", Some("password"))
+        .header(CONNECTION, "close")
+        .send()
+        .unwrap();
+
+    let body = res.text().unwrap();
+
+    println!("{}", body);
+}

Task/HTTPS-Authenticated/Scala/https-authenticated.scala

@@ -0,0 +1,24 @@
+import java.net.{Authenticator, PasswordAuthentication, URL}
+
+import javax.net.ssl.HttpsURLConnection
+
+import scala.io.BufferedSource
+
+
+object Authenticated extends App {
+
+  val con: HttpsURLConnection =
+    new URL("https://somehost.com").openConnection().asInstanceOf[HttpsURLConnection]
+
+  object PasswordAuthenticator extends Authenticator {
+    override def getPasswordAuthentication =
+      new PasswordAuthentication("username", "password".toCharArray)
+  }
+
+  Authenticator.setDefault(PasswordAuthenticator)
+  con.setAllowUserInteraction(true)
+  con.connect()
+
+  new BufferedSource(con.getInputStream).getLines.foreach(println(_))
+
+}

Task/HTTPS-Authenticated/Sidef/https-authenticated.sidef

@@ -0,0 +1,14 @@
+require('WWW::Mechanize')
+
+var mech = %s'WWW::Mechanize'.new(
+    cookie_jar => Hash.new,
+    agent => 'Mozilla/5.0',
+)
+
+mech.get('https://login.yahoo.com/')
+mech.submit_form(
+    form_id => 'mbr-login-form',   # form id
+    fields => Hash.new(
+        'login'  => 'XXXXXX',
+        'passwd' => 'YYYYYY',
+))

Task/HTTPS-Authenticated/Tcl/https-authenticated.tcl

@@ -0,0 +1,15 @@
+package require http
+package require tls
+http::register https 443 ::tls::socket
+
+# Generate the authentication
+set user theUser
+set pass thePassword
+dict set auth Authenticate "Basic [binary encode base64 ${user}:${pass}]"
+
+# Make a secure authenticated connection
+set token [http::geturl https://secure.example.com/ -headers $auth]
+
+# Now as for conventional use of the “http” package
+set data [http::data $token]
+http::cleanup $token

Task/HTTPS-Authenticated/Visual-Basic/https-authenticated.vb

@@ -0,0 +1,22 @@
+Sub Main()
+'  in the "references" dialog of the IDE, check
+'  "Microsoft WinHTTP Services, version 5.1" (winhttp.dll)
+Dim HttpReq As WinHttp.WinHttpRequest
+Const WINHTTP_FLAG_SECURE_PROTOCOL_TLS1     As Long = &H80&
+Const WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1   As Long = &H200&
+Const WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_2   As Long = &H800&
+Const HTTPREQUEST_PROXYSETTING_PROXY        As Long = 2
+#Const USE_PROXY = 1
+  Set HttpReq = New WinHttp.WinHttpRequest
+  HttpReq.Open "GET", "https://www.abc.com/xyz/index.html"
+  HttpReq.Option(WinHttpRequestOption_SecureProtocols) = WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 Or _
+                                                         WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1 Or _
+                                                         WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_2
+  HttpReq.SetCredentials "<username>", "<password>", 0&
+#If USE_PROXY Then
+  HttpReq.SetProxy HTTPREQUEST_PROXYSETTING_PROXY, "10.167.1.1:80"
+#End If
+  HttpReq.SetTimeouts 1000, 1000, 1000, 1000
+  HttpReq.Send
+  Debug.Print HttpReq.ResponseText
+End Sub

Task/HTTPS-Authenticated/Wren/https-authenticated-1.wren

@@ -0,0 +1,31 @@
+/* https_authenticated.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://user:password@secure.example.com/")
+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()

Task/HTTPS-Authenticated/Wren/https-authenticated-2.wren

@@ -0,0 +1,127 @@
+/* gcc https_authenticated.c -o https_authenticated -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_authenticated.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;
+}

Task/HTTPS-Authenticated/Zkl/https-authenticated.zkl

@@ -0,0 +1,4 @@
+zkl: var ZC=Import("zklCurl")
+zkl: var data=ZC().get("http://usr:pw@192.168.1.1/computer_list.xml")
+L(Data(1,049),121,0)
+zkl: data[0][121,*].text