HTTPS: Difference between revisions

{{task|Programming environment operations}}

[[Category:Networking and Web Interaction]]

;Task:

=={{header|Ada}}==

{{libheader|AWS}}

Exactly the same as the HTTP task, assuming you compiled AWS with openssl support.

with AWS.Client;

with AWS.Response;

URL => "https://sourceforge.net/")));

end GetHttps;

 

=={{header|AutoHotkey}}==

{{libheader|wininet}}

URL := "https://sourceforge.net/"

WININET_Init()

#include urlgetcontents.ahk

#include wininet.ahk

 

=={{header|BaCon}}==

website$ = "www.google.com"

 

 

PRINT REPLACE$(total$, "\r\n[0-9a-fA-F]+\r\n", "\r\n", TRUE) : ' Remove chunk indicators from HTML data

 

=={{header|Batch File}}==

:: Must have curl.exe

curl.exe -k -s -L https://sourceforge.net/

 

=={{header|C}}==

{{libheader|libcurl}}

#include <stdlib.h>

#include <curl/curl.h>

}

 

=={{header|C sharp|C#}}==

{{works with|C sharp|3.0}}

 

using System;

using System.Net;

}

}

 

This does not work for urls requiring a secure (SSL) connection.

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"))

 

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"))

 

=={{header|Common Lisp}}==

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."

;; Use

(wget-drakma-stream "https://sourceforge.net")

 

=={{header|Delphi}}==

{{libheader|OpenSSL}}

program ShowHTTPS;

 

end;

end.

 

=={{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")

 

=={{header|Erlang}}==

===Synchronous===

-module(main).

-export([main/1]).

{error, Res} -> io:fwrite("~p~n", [Res])

end.

 

===Asynchronous===

-module(main).

-export([main/1]).

after 10000 -> io:fwrite("Timed out.~n",[])

end.

 

Using it

|escript ./req.erl https://sourceforge.net/

 

=={{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)

 

=={{header|Frink}}==

 

=={{header|Go}}==

package main

 

io.Copy(os.Stdout, r.Body)

}

 

=={{header|Groovy}}==

new URL("https://sourceforge.net").eachLine { println it }

 

=={{header|Haskell}}==

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

 

main = withSocketsDo

 

==Icon and {{header|Unicon}}==

procedure main(arglist)

url := (\arglist[1] | "https://sourceforge.net/")

while write(read(w))

close(w)

 

{{out}}

=={{header|Ioke}}==

{{trans|Java}}

connection = URL new("https://sourceforge.net") openConnection

scanner = Scanner new(connection getInputStream)

scanner next println

)

 

=={{header|J}}==

Using <tt>gethttp</tt> from [[Web Scraping#J|Web Scraping]]

 

#page=: gethttp'https://sourceforge.net'

0

#page=: '--no-check-certificate' gethttp'https://sourceforge.net'

900

 

(We can not load the example page using https unless we disable certificate checking. The numbers are the number of characters retrieved.)

 

=={{header|Java}}==

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.

URL url = new URL("https://sourceforge.net");

HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();

System.out.println(scanner.next());

}

 

=={{header|JavaScript}}==

 

=={{header|Julia}}==

 

using Requests

 

 

=={{header|Kotlin}}==

 

import java.net.URL

import javax.net.ssl.HttpsURLConnection

while (sc.hasNextLine()) println(sc.nextLine())

sc.close()

 

=={{header|Lasso}}==

local(y = #x->result)

 

If a site with an invalid SSL Cert is encountered the curl type throws the following error:

*Windows:

{{libheader|Curl Xtra}}

CURLOPT_URL = 10002

ch.setOption(CURLOPT_URL, "https://sourceforge.net")

put "Result:" && res.readRawString(res.length)

end if

 

*Mac OS X:

{{libheader|Shell Xtra}}

 

=={{header|LiveCode}}==

Non-blocking version, execute getWebResource

get URL "https://sourceforge.net/" -- this will now fetch a locally cached copy

put it

libURLSetSSLVerification true --check cert

load URL "https://sourceforge.net/" with message "myUrlDownloadFinished"

 

=={{header|LSL}}==

 

To test it yourself; rez a box on the ground, and add the following as a New Script.

key kHttpRequestId;

default {

}

}

Output:

<pre>Status=200

{{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()

local status = headers:get(':status')

io.write(string.format('Status: %d\nBody: %s\n', status, body)

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}}==

content := URL:-Get( "https://www.google.ca/" );

 

=={{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.

content=Import["https://sourceforge.net", "HTML"]

 

=={{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;

myStream.Close()

}

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

{{libheader|OpenSSL}}

Compile with <code>nim c -d:ssl httpsClient.nim</code>:

 

var client = newHttpClient()

 

=={{header|Objeck}}==

use HTTP;

 

}

}

 

=={{header|Pascal}}==

{{works with|Free Pascal}}

Using [http://wiki.freepascal.org/fphttpclient fphttpclient]

uses fphttpclient;

 

end;

writeln(s)

 

=={{header|Perl}}==

{{libheader|LWP}}

use strict;

use LWP::UserAgent;

 

print $response->as_string;

 

=={{header|Phix}}==

Exactly the same as the [[HTTP#Phix]] task.

 

=={{header|PHP}}==

echo file_get_contents('https://sourceforge.net');

 

=={{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

(in '(curl "https://sourceforge.net") # Open a pipe to 'curl'

(out NIL (echo)) ) # Echo to standard output

 

=={{header|Pike}}==

int main() {

write("%s\n", Protocols.HTTP.get_url_data("https://sourceforge.net"));

}

 

=={{header|PowerShell}}==

$wc = New-Object Net.WebClient

$wc.DownloadString('https://sourceforge.net')

 

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.

 

=={{header|Python}}==

 

=={{header|R}}==

 

The basic idea is to use getURL (as with [[HTTP_Request]]), but with some extra parameters.

In this case, the webpage output contains unprocessed characters, e.g. \" instead of " and \\ instead of \, so we need to process the markup.

 

wp <- readLines(tc <- textConnection(webpage))

close(tc)

 

Finally, we parse the HTML and find the interesting bit.

 

pagetree <- htmlTreeParse(wp)

pagetree$children$html

 

=={{header|Racket}}==

#lang racket

(require net/url)

#:redirections 100)

(current-output-port))

 

=={{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.

 

Dim sock As New HTTPSecureSocket

Print(sock.Get("https://sourceforge.net", 10)) //set the timeout period to 10 seconds.

 

=={{header|Ring}}==

cStr= download("http://sourceforge.net/")

see cStr + nl

 

=={{header|RLaB}}==

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'

puts content.body

end

 

outputs

</body>

</html>

</pre>

 

=={{header|Scala}}==

{{libheader|Scala}}

 

object HttpsTest extends App {

Source.fromURL("https://sourceforge.net").getLines.foreach(println)

 

=={{header|Seed7}}==

HTTPS protocol go get a file.

 

include "gethttps.s7i";

include "utf8.s7i";

begin

writeln(STD_UTF8_OUT, getHttps("sourceforge.net"));

 

=={{header|Sidef}}==

 

 

 

=={{header|Swift}}==

 

// With https

}

 

 

=={{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

puts [http::data $token]

http::cleanup $token

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

SET DATEN = REQUEST ("https://sourceforge.net")

*{daten}

 

=={{header|UNIX Shell}}==

curl -k -s -L https://sourceforge.net/

 

=={{header|VBScript}}==

 

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]

Option Explicit

 

 

Set oHTTP = Nothing

 

=={{header|Visual Basic .NET}}==

Imports System.Net

 

Dim content As String = client.DownloadString("https://sourceforge.net")

Console.WriteLine(content)

 

=={{header|zkl}}==

Using the cURL library to do the heavy lifting:

zkl: var data=ZC().get("https://sourceforge.net")

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

{{omit from|Brainf***}}

{{omit from|Commodore BASIC|Does not have network access}}

{{omit from|Inform 7|Does not have network access.}}

{{omit from|Integer BASIC|No TCP/IP network support on Apple II}}