Support for LibreSSL

builder/builder.go

@@ -23,6 +23,7 @@ var (
 	pcreVersionRe      *regexp.Regexp
 	zlibVersionRe      *regexp.Regexp
 	opensslVersionRe   *regexp.Regexp
+	libresslVersionRe  *regexp.Regexp
 	openrestyVersionRe *regexp.Regexp
 	tengineVersionRe   *regexp.Regexp
 )
@@ -32,6 +33,7 @@ func init() {
 	pcreVersionRe = regexp.MustCompile(`--with-pcre=.+/pcre-(\d+\.\d+)`)
 	zlibVersionRe = regexp.MustCompile(`--with-zlib=.+/zlib-(\d+\.\d+\.\d+)`)
 	opensslVersionRe = regexp.MustCompile(`--with-openssl=.+/openssl-(\d+\.\d+\.\d+[a-z]+)`)
+	libresslVersionRe = regexp.MustCompile(`--with-openssl=.+/libressl-(\d+\.\d+\.\d+)`)
 	openrestyVersionRe = regexp.MustCompile(`nginx version: openresty/(\d+\.\d+\.\d+\.\d+)`)
 	tengineVersionRe = regexp.MustCompile(`Tengine version: Tengine/(\d+\.\d+\.\d+)`)
 }
@@ -45,6 +47,8 @@ func (builder *Builder) name() string {
 		name = "pcre"
 	case ComponentOpenSSL:
 		name = "openssl"
+	case ComponentLibreSSL:
+		name = "libressl"
 	case ComponentZlib:
 		name = "zlib"
 	case ComponentOpenResty:
@@ -58,7 +62,14 @@ func (builder *Builder) name() string {
 }
 
 func (builder *Builder) option() string {
-	return fmt.Sprintf("--with-%s", builder.name())
+	name := builder.name()
+
+	// only libressl does not match option name
+	if name == "libressl" {
+		name = "openssl"
+	}
+
+	return fmt.Sprintf("--with-%s", name)
 }
 
 func (builder *Builder) DownloadURL() string {
@@ -119,6 +130,8 @@ func (builder *Builder) InstalledVersion() (string, error) {
 		versionRe = pcreVersionRe
 	case "openssl":
 		versionRe = opensslVersionRe
+	case "libressl":
+		versionRe = libresslVersionRe
 	case "tengine":
 		versionRe = tengineVersionRe
 	}
@@ -141,6 +154,8 @@ func MakeBuilder(component int, version string) Builder {
 		builder.DownloadURLPrefix = PcreDownloadURLPrefix
 	case ComponentOpenSSL:
 		builder.DownloadURLPrefix = OpenSSLDownloadURLPrefix
+	case ComponentLibreSSL:
+		builder.DownloadURLPrefix = LibreSSLDownloadURLPrefix
 	case ComponentZlib:
 		builder.DownloadURLPrefix = ZlibDownloadURLPrefix
 	case ComponentOpenResty:

builder/builder_test.go

@@ -19,6 +19,7 @@ func (suite *BuilderTestSuite) SetupTest() {
 	suite.builders[ComponentNginx] = MakeBuilder(ComponentNginx, NginxVersion)
 	suite.builders[ComponentPcre] = MakeLibraryBuilder(ComponentPcre, PcreVersion, false)
 	suite.builders[ComponentOpenSSL] = MakeLibraryBuilder(ComponentOpenSSL, OpenSSLVersion, true)
+	suite.builders[ComponentLibreSSL] = MakeLibraryBuilder(ComponentLibreSSL, LibreSSLVersion, true)
 	suite.builders[ComponentZlib] = MakeLibraryBuilder(ComponentZlib, ZlibVersion, false)
 	suite.builders[ComponentOpenResty] = MakeBuilder(ComponentOpenResty, OpenRestyVersion)
 	suite.builders[ComponentTengine] = MakeBuilder(ComponentTengine, TengineVersion)
@@ -28,6 +29,7 @@ func (suite *BuilderTestSuite) TestName() {
 	assert.Equal(suite.T(), suite.builders[ComponentNginx].name(), "nginx")
 	assert.Equal(suite.T(), suite.builders[ComponentPcre].name(), "pcre")
 	assert.Equal(suite.T(), suite.builders[ComponentOpenSSL].name(), "openssl")
+	assert.Equal(suite.T(), suite.builders[ComponentLibreSSL].name(), "libressl")
 	assert.Equal(suite.T(), suite.builders[ComponentZlib].name(), "zlib")
 	assert.Equal(suite.T(), suite.builders[ComponentOpenResty].name(), "openresty")
 	assert.Equal(suite.T(), suite.builders[ComponentTengine].name(), "tengine")
@@ -36,13 +38,15 @@ func (suite *BuilderTestSuite) TestName() {
 func (suite *BuilderTestSuite) TestOption() {
 	assert.Equal(suite.T(), suite.builders[ComponentPcre].option(), "--with-pcre")
 	assert.Equal(suite.T(), suite.builders[ComponentOpenSSL].option(), "--with-openssl")
+	assert.Equal(suite.T(), suite.builders[ComponentLibreSSL].option(), "--with-openssl")
 	assert.Equal(suite.T(), suite.builders[ComponentZlib].option(), "--with-zlib")
 }
 
 func (suite *BuilderTestSuite) TestDownloadURL() {
 	assert.Equal(suite.T(), suite.builders[ComponentNginx].DownloadURL(), fmt.Sprintf("%s/nginx-%s.tar.gz", NginxDownloadURLPrefix, NginxVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentPcre].DownloadURL(), fmt.Sprintf("%s/pcre-%s.tar.gz", PcreDownloadURLPrefix, PcreVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenSSL].DownloadURL(), fmt.Sprintf("%s/openssl-%s.tar.gz", OpenSSLDownloadURLPrefix, OpenSSLVersion))
+	assert.Equal(suite.T(), suite.builders[ComponentLibreSSL].DownloadURL(), fmt.Sprintf("%s/libressl-%s.tar.gz", LibreSSLDownloadURLPrefix, LibreSSLVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentZlib].DownloadURL(), fmt.Sprintf("%s/zlib-%s.tar.gz", ZlibDownloadURLPrefix, ZlibVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenResty].DownloadURL(), fmt.Sprintf("%s/openresty-%s.tar.gz", OpenRestyDownloadURLPrefix, OpenRestyVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentTengine].DownloadURL(), fmt.Sprintf("%s/tengine-%s.tar.gz", TengineDownloadURLPrefix, TengineVersion))
@@ -52,6 +56,7 @@ func (suite *BuilderTestSuite) TestSourcePath() {
 	assert.Equal(suite.T(), suite.builders[ComponentNginx].SourcePath(), fmt.Sprintf("nginx-%s", NginxVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentPcre].SourcePath(), fmt.Sprintf("pcre-%s", PcreVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenSSL].SourcePath(), fmt.Sprintf("openssl-%s", OpenSSLVersion))
+	assert.Equal(suite.T(), suite.builders[ComponentLibreSSL].SourcePath(), fmt.Sprintf("libressl-%s", LibreSSLVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentZlib].SourcePath(), fmt.Sprintf("zlib-%s", ZlibVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenResty].SourcePath(), fmt.Sprintf("openresty-%s", OpenRestyVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentTengine].SourcePath(), fmt.Sprintf("tengine-%s", TengineVersion))
@@ -61,6 +66,7 @@ func (suite *BuilderTestSuite) TestArchivePath() {
 	assert.Equal(suite.T(), suite.builders[ComponentNginx].ArchivePath(), fmt.Sprintf("nginx-%s.tar.gz", NginxVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentPcre].ArchivePath(), fmt.Sprintf("pcre-%s.tar.gz", PcreVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenSSL].ArchivePath(), fmt.Sprintf("openssl-%s.tar.gz", OpenSSLVersion))
+	assert.Equal(suite.T(), suite.builders[ComponentLibreSSL].ArchivePath(), fmt.Sprintf("libressl-%s.tar.gz", LibreSSLVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentZlib].ArchivePath(), fmt.Sprintf("zlib-%s.tar.gz", ZlibVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenResty].ArchivePath(), fmt.Sprintf("openresty-%s.tar.gz", OpenRestyVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentTengine].ArchivePath(), fmt.Sprintf("tengine-%s.tar.gz", TengineVersion))
@@ -70,6 +76,7 @@ func (suite *BuilderTestSuite) TestLogPath() {
 	assert.Equal(suite.T(), suite.builders[ComponentNginx].LogPath(), fmt.Sprintf("nginx-%s.log", NginxVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentPcre].LogPath(), fmt.Sprintf("pcre-%s.log", PcreVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenSSL].LogPath(), fmt.Sprintf("openssl-%s.log", OpenSSLVersion))
+	assert.Equal(suite.T(), suite.builders[ComponentLibreSSL].LogPath(), fmt.Sprintf("libressl-%s.log", LibreSSLVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentZlib].LogPath(), fmt.Sprintf("zlib-%s.log", ZlibVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentOpenResty].LogPath(), fmt.Sprintf("openresty-%s.log", OpenRestyVersion))
 	assert.Equal(suite.T(), suite.builders[ComponentTengine].LogPath(), fmt.Sprintf("tengine-%s.log", TengineVersion))
@@ -78,12 +85,14 @@ func (suite *BuilderTestSuite) TestLogPath() {
 func (suite *BuilderTestSuite) TestLibrary() {
 	assert.Equal(suite.T(), suite.builders[ComponentPcre].Static, false)
 	assert.Equal(suite.T(), suite.builders[ComponentOpenSSL].Static, true)
+	assert.Equal(suite.T(), suite.builders[ComponentLibreSSL].Static, true)
 	assert.Equal(suite.T(), suite.builders[ComponentZlib].Static, false)
 }
 
 func (suite *BuilderTestSuite) TestMakeStaticLibrary() {
 	pcre := MakeStaticLibrary(&suite.builders[ComponentPcre])
 	openssl := MakeStaticLibrary(&suite.builders[ComponentOpenSSL])
+	libressl := MakeStaticLibrary(&suite.builders[ComponentLibreSSL])
 	zlib := MakeStaticLibrary(&suite.builders[ComponentZlib])
 
 	assert.Equal(suite.T(), pcre.Name, suite.builders[ComponentPcre].name())
@@ -94,6 +103,10 @@ func (suite *BuilderTestSuite) TestMakeStaticLibrary() {
 	assert.Equal(suite.T(), openssl.Version, OpenSSLVersion)
 	assert.Equal(suite.T(), openssl.Option, suite.builders[ComponentOpenSSL].option())
 
+	assert.Equal(suite.T(), libressl.Name, suite.builders[ComponentLibreSSL].name())
+	assert.Equal(suite.T(), libressl.Version, LibreSSLVersion)
+	assert.Equal(suite.T(), libressl.Option, suite.builders[ComponentLibreSSL].option())
+
 	assert.Equal(suite.T(), zlib.Name, suite.builders[ComponentZlib].name())
 	assert.Equal(suite.T(), zlib.Version, ZlibVersion)
 	assert.Equal(suite.T(), zlib.Option, suite.builders[ComponentZlib].option())

builder/const.go

@@ -18,6 +18,12 @@ const (
 	OpenSSLDownloadURLPrefix = "https://www.openssl.org/source"
 )
 
+// libressl
+const (
+	LibreSSLVersion           = "2.5.4"
+	LibreSSLDownloadURLPrefix = "https://ftp.openbsd.org/pub/OpenBSD/LibreSSL"
+)
+
 // zlib
 const (
 	ZlibVersion           = "1.2.11"
@@ -43,6 +49,7 @@ const (
 	ComponentTengine
 	ComponentPcre
 	ComponentOpenSSL
+	ComponentLibreSSL
 	ComponentZlib
 	ComponentMax
 )

builder/nginx.go

@@ -43,6 +43,8 @@ func IsSameVersion(builders []Builder) (bool, error) {
 			fallthrough
 		case ComponentOpenSSL:
 			fallthrough
+		case ComponentLibreSSL:
+			fallthrough
 		case ComponentZlib:
 			if vi == "" && !b.Static {
 				continue

configure/generate.go

@@ -23,7 +23,7 @@ func Generate(configure string, modules3rd []module3rd.Module3rd, dependencies [
 
 	for _, d := range dependencies {
 		configure += fmt.Sprintf("%s=../%s-%s \\\n", d.Option, d.Name, d.Version)
-		if d.Name == "openssl" {
+		if d.Name == "openssl" || d.Name == "libressl" {
 			openSSLStatic = true
 		}
 	}

nginx-build.go

@@ -115,6 +115,7 @@ func main() {
 	verbose := nginxBuildOptions.Bools["verbose"].Enabled
 	pcreStatic := nginxBuildOptions.Bools["pcre"].Enabled
 	openSSLStatic := nginxBuildOptions.Bools["openssl"].Enabled
+	libreSSLStatic := nginxBuildOptions.Bools["libressl"].Enabled
 	zlibStatic := nginxBuildOptions.Bools["zlib"].Enabled
 	clear := nginxBuildOptions.Bools["clear"].Enabled
 	versionPrint := nginxBuildOptions.Bools["version"].Enabled
@@ -131,6 +132,7 @@ func main() {
 	workParentDir := nginxBuildOptions.Values["d"].Value
 	pcreVersion := nginxBuildOptions.Values["pcreversion"].Value
 	openSSLVersion := nginxBuildOptions.Values["opensslversion"].Value
+	libreSSLVersion := nginxBuildOptions.Values["libresslversion"].Value
 	zlibVersion := nginxBuildOptions.Values["zlibversion"].Value
 	openRestyVersion := nginxBuildOptions.Values["openrestyversion"].Value
 	tengineVersion := nginxBuildOptions.Values["tengineversion"].Value
@@ -188,6 +190,9 @@ func main() {
 	if *openResty && *tengine {
 		log.Fatal("select one between '-openresty' and '-tengine'.")
 	}
+	if *openSSLStatic && *libreSSLStatic {
+		log.Fatal("select one between '-openssl' and '-libressl'.")
+	}
 	if *openResty {
 		nginxBuilder = builder.MakeBuilder(builder.ComponentOpenResty, *openRestyVersion)
 	} else if *tengine {
@@ -197,13 +202,15 @@ func main() {
 	}
 	pcreBuilder := builder.MakeLibraryBuilder(builder.ComponentPcre, *pcreVersion, *pcreStatic)
 	openSSLBuilder := builder.MakeLibraryBuilder(builder.ComponentOpenSSL, *openSSLVersion, *openSSLStatic)
+	libreSSLBuilder := builder.MakeLibraryBuilder(builder.ComponentLibreSSL, *libreSSLVersion, *libreSSLStatic)
 	zlibBuilder := builder.MakeLibraryBuilder(builder.ComponentZlib, *zlibVersion, *zlibStatic)
 
 	if *idempotent {
 		builders := []builder.Builder{
 			nginxBuilder,
 			pcreBuilder,
 			openSSLBuilder,
+			libreSSLBuilder,
 			zlibBuilder,
 		}
 
@@ -298,6 +305,14 @@ func main() {
 		}()
 	}
 
+	if *libreSSLStatic {
+		wg.Add(1)
+		go func() {
+			downloadAndExtractParallel(&libreSSLBuilder)
+			wg.Done()
+		}()
+	}
+
 	if *zlibStatic {
 		wg.Add(1)
 		go func() {
@@ -346,6 +361,10 @@ func main() {
 		dependencies = append(dependencies, builder.MakeStaticLibrary(&openSSLBuilder))
 	}
 
+	if *libreSSLStatic {
+		dependencies = append(dependencies, builder.MakeStaticLibrary(&libreSSLBuilder))
+	}
+
 	if *zlibStatic {
 		dependencies = append(dependencies, builder.MakeStaticLibrary(&zlibBuilder))
 	}
@@ -358,7 +377,10 @@ func main() {
 
 	if *openSSLStatic && openSSLBuilder.IsIncludeWithOption(nginxConfigure) {
 		log.Println(openSSLBuilder.WarnMsgWithLibrary())
+	}
 
+	if *libreSSLStatic && libreSSLBuilder.IsIncludeWithOption(nginxConfigure) {
+		log.Println(libreSSLBuilder.WarnMsgWithLibrary())
 	}
 
 	if *zlibStatic && zlibBuilder.IsIncludeWithOption(nginxConfigure) {

option.go

@@ -52,6 +52,9 @@ func makeNginxBuildOptions() Options {
 	argsBool["openssl"] = OptionBool{
 		Desc: "embedded OpenSSL staticlibrary",
 	}
+	argsBool["libressl"] = OptionBool{
+		Desc: "embedded LibreSSL staticlibrary",
+	}
 	argsBool["zlib"] = OptionBool{
 		Desc: "embedded zlib staticlibrary",
 	}
@@ -104,6 +107,10 @@ func makeNginxBuildOptions() Options {
 		Desc:    "OpenSSL version",
 		Default: builder.OpenSSLVersion,
 	}
+	argsString["libresslversion"] = OptionValue{
+		Desc:    "LibreSSL version",
+		Default: builder.LibreSSLVersion,
+	}
 	argsString["zlibversion"] = OptionValue{
 		Desc:    "zlib version",
 		Default: builder.ZlibVersion,