implement version check functions in Go using special tags

Author: qmuntal

cipher.go

@@ -84,7 +84,7 @@ func loadCipher(k cipherKind, mode cipherMode) (cipher _EVP_CIPHER_PTR) {
 			// not created by EVP_CIPHER has negative performance
 			// implications, as cipher operations will have
 			// to fetch it on every call. Better to just fetch it once here.
-			cipher = go_openssl_EVP_CIPHER_fetch(nil, go_openssl_EVP_CIPHER_get0_name(cipher), nil)
+			cipher, _ = go_openssl_EVP_CIPHER_fetch(nil, go_openssl_EVP_CIPHER_get0_name(cipher), nil)
 		}
 		cacheCipher.Store(cacheCipherKey{k, mode}, cipher)
 	}()
@@ -178,8 +178,8 @@ func (c *evpCipher) encrypt(dst, src []byte) error {
 	defer go_openssl_EVP_CIPHER_CTX_free(enc_ctx)
 
 	var outl int32
-	if go_openssl_EVP_EncryptUpdate(enc_ctx, base(dst), &outl, base(src), int32(c.blockSize)) != 1 {
-		return errors.New("EncryptUpdate failed")
+	if _, err := go_openssl_EVP_EncryptUpdate(enc_ctx, base(dst), &outl, base(src), int32(c.blockSize)); err != nil {
+		return err
 	}
 	runtime.KeepAlive(c)
 	return nil
@@ -203,8 +203,8 @@ func (c *evpCipher) decrypt(dst, src []byte) error {
 	}
 	defer go_openssl_EVP_CIPHER_CTX_free(dec_ctx)
 
-	if go_openssl_EVP_CIPHER_CTX_set_padding(dec_ctx, 0) != 1 {
-		return errors.New("could not disable cipher padding")
+	if _, err := go_openssl_EVP_CIPHER_CTX_set_padding(dec_ctx, 0); err != nil {
+		return err
 	}
 
 	var outl int32
@@ -236,19 +236,19 @@ func (x *cipherCBC) CryptBlocks(dst, src []byte) {
 	}
 	if len(src) > 0 {
 		var outl int32
-		if go_openssl_EVP_CipherUpdate(x.ctx, base(dst), &outl, base(src), int32(len(src))) != 1 {
-			panic("crypto/cipher: CipherUpdate failed")
+		if _, err := go_openssl_EVP_CipherUpdate(x.ctx, base(dst), &outl, base(src), int32(len(src))); err != nil {
+			panic("crypto/cipher: " + err.Error())
 		}
 		runtime.KeepAlive(x)
 	}
 }
 
 func (x *cipherCBC) SetIV(iv []byte) {
 	if len(iv) != x.blockSize {
-		panic("cipher: incorrect length IV")
+		panic("crypto/cipher: incorrect length IV")
 	}
-	if go_openssl_EVP_CipherInit_ex(x.ctx, nil, nil, nil, base(iv), int32(cipherOpNone)) != 1 {
-		panic("cipher: unable to initialize EVP cipher ctx")
+	if _, err := go_openssl_EVP_CipherInit_ex(x.ctx, nil, nil, nil, base(iv), int32(cipherOpNone)); err != nil {
+		panic("crypto/cipher: " + err.Error())
 	}
 }
 
@@ -259,8 +259,8 @@ func (c *evpCipher) newCBC(iv []byte, op cipherOp) cipher.BlockMode {
 	}
 	x := &cipherCBC{ctx: ctx, blockSize: c.blockSize}
 	runtime.SetFinalizer(x, (*cipherCBC).finalize)
-	if go_openssl_EVP_CIPHER_CTX_set_padding(x.ctx, 0) != 1 {
-		panic("cipher: unable to set padding")
+	if _, err := go_openssl_EVP_CIPHER_CTX_set_padding(x.ctx, 0); err != nil {
+		panic("crypto/cipher: " + err.Error())
 	}
 	return x
 }
@@ -280,8 +280,8 @@ func (x *cipherCTR) XORKeyStream(dst, src []byte) {
 		return
 	}
 	var outl int32
-	if go_openssl_EVP_EncryptUpdate(x.ctx, base(dst), &outl, base(src), int32(len(src))) != 1 {
-		panic("crypto/cipher: EncryptUpdate failed")
+	if _, err := go_openssl_EVP_EncryptUpdate(x.ctx, base(dst), &outl, base(src), int32(len(src))); err != nil {
+		panic("crypto/cipher: " + err.Error())
 	}
 	runtime.KeepAlive(x)
 }
@@ -455,22 +455,24 @@ func (g *cipherGCM) Seal(dst, nonce, plaintext, aad []byte) []byte {
 	// relying in the explicit nonce being securely set externally,
 	// and it also gives some interesting speed gains.
 	// Unfortunately we can't use it because Go expects AEAD.Seal to honor the provided nonce.
-	if go_openssl_EVP_EncryptInit_ex(ctx, nil, nil, nil, base(nonce)) != 1 {
-		panic(newOpenSSLError("EVP_EncryptInit_ex"))
+	if _, err := go_openssl_EVP_EncryptInit_ex(ctx, nil, nil, nil, base(nonce)); err != nil {
+		panic(err)
 	}
 	var outl, discard int32
-	if go_openssl_EVP_EncryptUpdate(ctx, nil, &discard, baseNeverEmpty(aad), int32(len(aad))) != 1 ||
-		go_openssl_EVP_EncryptUpdate(ctx, base(out), &outl, baseNeverEmpty(plaintext), int32(len(plaintext))) != 1 {
-		panic(newOpenSSLError("EVP_EncryptUpdate"))
+	if _, err := go_openssl_EVP_EncryptUpdate(ctx, nil, &discard, baseNeverEmpty(aad), int32(len(aad))); err != nil {
+		panic(err)
+	}
+	if _, err := go_openssl_EVP_EncryptUpdate(ctx, base(out), &outl, baseNeverEmpty(plaintext), int32(len(plaintext))); err != nil {
+		panic(err)
 	}
 	if len(plaintext) != int(outl) {
 		panic("cipher: incorrect length returned from GCM EncryptUpdate")
 	}
-	if go_openssl_EVP_EncryptFinal_ex(ctx, base(out[outl:]), &discard) != 1 {
-		panic(newOpenSSLError("EVP_EncryptFinal_ex"))
+	if _, err := go_openssl_EVP_EncryptFinal_ex(ctx, base(out[outl:]), &discard); err != nil {
+		panic(err)
 	}
-	if go_openssl_EVP_CIPHER_CTX_ctrl(ctx, _EVP_CTRL_GCM_GET_TAG, 16, unsafe.Pointer(base(out[outl:]))) != 1 {
-		panic(newOpenSSLError("EVP_CIPHER_CTX_ctrl"))
+	if _, err := go_openssl_EVP_CIPHER_CTX_ctrl(ctx, _EVP_CTRL_GCM_GET_TAG, 16, unsafe.Pointer(base(out[outl:]))); err != nil {
+		panic(err)
 	}
 	runtime.KeepAlive(g)
 	return ret
@@ -515,21 +517,23 @@ func (g *cipherGCM) Open(dst, nonce, ciphertext, aad []byte) (_ []byte, err erro
 			}
 		}
 	}()
-	if go_openssl_EVP_DecryptInit_ex(ctx, nil, nil, nil, base(nonce)) != 1 {
+	if _, err := go_openssl_EVP_DecryptInit_ex(ctx, nil, nil, nil, base(nonce)); err != nil {
 		return nil, errOpen
 	}
-	if go_openssl_EVP_CIPHER_CTX_ctrl(ctx, _EVP_CTRL_GCM_SET_TAG, 16, unsafe.Pointer(base(tag))) != 1 {
+	if _, err := go_openssl_EVP_CIPHER_CTX_ctrl(ctx, _EVP_CTRL_GCM_SET_TAG, 16, unsafe.Pointer(base(tag))); err != nil {
 		return nil, errOpen
 	}
 	var outl, discard int32
-	if go_openssl_EVP_DecryptUpdate(ctx, nil, &discard, baseNeverEmpty(aad), int32(len(aad))) != 1 ||
-		go_openssl_EVP_DecryptUpdate(ctx, base(out), &outl, baseNeverEmpty(ciphertext), int32(len(ciphertext))) != 1 {
+	if _, err := go_openssl_EVP_DecryptUpdate(ctx, nil, &discard, baseNeverEmpty(aad), int32(len(aad))); err != nil {
+		return nil, errOpen
+	}
+	if _, err := go_openssl_EVP_DecryptUpdate(ctx, base(out), &outl, baseNeverEmpty(ciphertext), int32(len(ciphertext))); err != nil {
 		return nil, errOpen
 	}
 	if len(ciphertext) != int(outl) {
 		return nil, errOpen
 	}
-	if go_openssl_EVP_DecryptFinal_ex(ctx, base(out[outl:]), &discard) != 1 {
+	if _, err := go_openssl_EVP_DecryptFinal_ex(ctx, base(out[outl:]), &discard); err != nil {
 		return nil, errOpen
 	}
 	runtime.KeepAlive(g)
@@ -553,9 +557,9 @@ func newCipherCtx(kind cipherKind, mode cipherMode, encrypt cipherOp, key, iv []
 	if cipher == nil {
 		panic("crypto/cipher: unsupported cipher: " + kind.String())
 	}
-	ctx := go_openssl_EVP_CIPHER_CTX_new()
-	if ctx == nil {
-		return nil, fail("unable to create EVP cipher ctx")
+	ctx, err := go_openssl_EVP_CIPHER_CTX_new()
+	if err != nil {
+		return nil, err
 	}
 	defer func() {
 		if err != nil {
@@ -566,17 +570,17 @@ func newCipherCtx(kind cipherKind, mode cipherMode, encrypt cipherOp, key, iv []
 		// RC4 cipher supports a variable key length.
 		// We need to set the key length before setting the key,
 		// and to do so we need to have an initialized cipher ctx.
-		if go_openssl_EVP_CipherInit_ex(ctx, cipher, nil, nil, nil, int32(encrypt)) != 1 {
-			return nil, newOpenSSLError("EVP_CipherInit_ex")
+		if _, err := go_openssl_EVP_CipherInit_ex(ctx, cipher, nil, nil, nil, int32(encrypt)); err != nil {
+			return nil, err
 		}
-		if go_openssl_EVP_CIPHER_CTX_set_key_length(ctx, int32(len(key))) != 1 {
-			return nil, newOpenSSLError("EVP_CIPHER_CTX_set_key_length")
+		if _, err := go_openssl_EVP_CIPHER_CTX_set_key_length(ctx, int32(len(key))); err != nil {
+			return nil, err
 		}
 		// Pass nil to the next call to EVP_CipherInit_ex to avoid resetting ctx's cipher.
 		cipher = nil
 	}
-	if go_openssl_EVP_CipherInit_ex(ctx, cipher, nil, base(key), base(iv), int32(encrypt)) != 1 {
-		return nil, newOpenSSLError("unable to initialize EVP cipher ctx")
+	if _, err := go_openssl_EVP_CipherInit_ex(ctx, cipher, nil, base(key), base(iv), int32(encrypt)); err != nil {
+		return nil, err
 	}
 	return ctx, nil
 }

cmd/mkcgo/generate.go

@@ -54,6 +54,11 @@ func generateGo(src *mkcgo.Source, w io.Writer) {
 		fmt.Fprintf(w, "}\n\n")
 	}
 
+	typedefs := make(map[string]string, len(src.TypeDefs))
+	for _, def := range src.TypeDefs {
+		typedefs[def.Name] = def.Type
+	}
+
 	// Generate function wrappers.
 	for _, fn := range src.Funcs {
 		if fn.Variadic() {
@@ -66,7 +71,7 @@ func generateGo(src *mkcgo.Source, w io.Writer) {
 			fmt.Fprintf(w, "\treturn C.%s_Available() != 0\n", fn.ImportName)
 			fmt.Fprintf(w, "}\n\n")
 		}
-		generateGoFn(fn, w)
+		generateGoFn(typedefs, fn, w)
 	}
 }
 
@@ -226,31 +231,75 @@ func generateC(src *mkcgo.Source, w io.Writer) {
 }
 
 // generateGoFn generates Go function f.
-func generateGoFn(fn *mkcgo.Func, w io.Writer) {
+func generateGoFn(typedefs map[string]string, fn *mkcgo.Func, w io.Writer) {
+	fnCall := fmt.Sprintf("C.%s(%s)", fn.CName, fnToGoArgs(fn))
+	// Function definition
 	fmt.Fprintf(w, "func %s(%s)", fn.GoName, fnToGoParams(fn))
-	if !retIsVoid(fn.Ret) {
-		fmt.Fprintf(w, " %s ", cTypeToGo(fn.Ret.Type, false))
+	if retIsVoid(fn.Ret) {
+		// Easy path, just call the C function. No need to write the return types,
+		// nor do error handling, nor cast the return value.
+		fmt.Fprintf(w, "{\n")
+		fmt.Fprintf(w, "\t%s\n", fnCall)
+		fmt.Fprintf(w, "}\n\n")
+		return
+	}
+	typ, _ := cTypeToGo(fn.Ret.Type, false)
+	if fn.NoError {
+		fmt.Fprintf(w, " %s ", typ)
+	} else {
+		fmt.Fprintf(w, " (%s, error) ", typ)
 	}
 	fmt.Fprintf(w, "{\n")
-	fmt.Fprintf(w, "\t")
-	var closePar int
-	if !retIsVoid(fn.Ret) {
-		fmt.Fprintf(w, "return ")
-		goType := cTypeToGo(fn.Ret.Type, false)
-		if goType != "" && goType != fn.Ret.Type {
-			closePar++
-			if goType[0] == '*' {
-				goType = fmt.Sprintf("(%s)(unsafe.Pointer", goType)
-				closePar++
+
+	// Function call
+	var needUnsafeCast bool
+	goType, needCast := cTypeToGo(fn.Ret.Type, false)
+	if needCast && goType[0] == '*' {
+		goType = fmt.Sprintf("(%s)(unsafe.Pointer", goType)
+		needUnsafeCast = true
+	}
+	if fn.NoError {
+		// No error handling, just cast the return value if necessary.
+		fmt.Fprintf(w, "\treturn ")
+		if needCast {
+			fmt.Fprintf(w, "%s(%s)", goType, fnCall)
+			if needUnsafeCast {
+				fmt.Fprintf(w, ")")
 			}
-			fmt.Fprintf(w, "%s(", goType)
+		} else {
+			fmt.Fprintf(w, "%s", fnCall)
 		}
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "}\n\n")
+		return
 	}
-	fmt.Fprintf(w, "C.%s(%s)", fn.CName, fnToGoArgs(fn))
-	if closePar > 0 {
-		fmt.Fprint(w, strings.Repeat(")", closePar))
+	fmt.Fprintf(w, "\t_ret := C.%s(%s)\n", fn.CName, fnToGoArgs(fn))
+
+	// Error handling
+	errCond := "<= 0"
+	if fn.ErrCond != "" {
+		errCond = fn.ErrCond
+	} else if strings.Contains(goType, "unsafe.Pointer") {
+		errCond = "== nil"
+	} else if typ, ok := typedefs[goType]; ok && typ == "void*" {
+		errCond = "== nil"
 	}
-	fmt.Fprintf(w, "\n")
+	fmt.Fprintf(w, "\tvar _err error\n")
+	fmt.Fprintf(w, "\tif _ret %s {\n", errCond)
+	fmt.Fprintf(w, "\t\t_err = newOpenSSLError(\"%s\")\n", fn.CName)
+	fmt.Fprintf(w, "\t}\n")
+
+	// Return the value
+	fmt.Fprintf(w, "\treturn ")
+	if needCast {
+		fmt.Fprintf(w, "%s(_ret)", goType)
+		if needUnsafeCast {
+			fmt.Fprintf(w, ")")
+		}
+	} else {
+		fmt.Fprintf(w, "_ret")
+	}
+	fmt.Fprintf(w, ", _err\n")
 	fmt.Fprintf(w, "}\n\n")
 }
 
@@ -265,7 +314,10 @@ func generateCFn(fn *mkcgo.Func, w io.Writer) {
 
 // paramToGo converts C parameter p to Go parameter.
 func paramToGo(p *mkcgo.Param) string {
-	goType := cTypeToGo(p.Type, true)
+	goType, needCast := cTypeToGo(p.Type, true)
+	if !needCast {
+		return p.Name
+	}
 	switch {
 	case goType == "unsafe.Pointer" || goType == "":
 		return p.Name
@@ -318,13 +370,17 @@ var cstdTypesToCgo = map[string]string{
 }
 
 // cTypeToGo converts C type t to a Go type.
-func cTypeToGo(t string, cgo bool) string {
+// If cgo is true, it returns the type that can be
+// passed to a cgo function call.
+// It returns the Go type and a boolean that reports whether
+// the type needs to be casted to goType or not.
+func cTypeToGo(t string, cgo bool) (string, bool) {
 	t, _ = strings.CutPrefix(t, "const ")
 	if t == "void" {
-		return ""
+		return "", true
 	}
 	if strings.HasPrefix(t, "void*") {
-		return "unsafe.Pointer"
+		return "unsafe.Pointer", false
 	}
 	if strings.HasSuffix(t, "*") {
 		// Remove all trailing '*' characters.
@@ -335,29 +391,25 @@ func cTypeToGo(t string, cgo bool) string {
 			}
 			n++
 		}
-		s := cTypeToGo(t[:i+1], cgo)
+		s, std := cTypeToGo(t[:i+1], cgo)
 		if s != "" {
 			s = strings.Repeat("*", n) + s
 		}
-		return s
+		return s, std
 	}
 	if !isStdType(t) {
-		if cgo {
-			// Non-standard C types are aliased so C.<type> so they don't need to be converted.
-			return ""
-		}
-		return t
+		return t, false
 	}
 	if cgo {
 		if s, ok := cstdTypesToCgo[t]; ok {
 			t = s
 		}
-		return "C." + t
+		return "C." + t, true
 	}
 	if t, ok := cstdTypesToGo[t]; ok {
-		return t
+		return t, true
 	}
-	return t
+	return t, true
 }
 
 // paramToC returns C source code of parameter p.
@@ -382,7 +434,8 @@ func retIsVoid(r *mkcgo.Return) bool {
 // fnToGoParams returns source code for function f parameters.
 func fnToGoParams(fn *mkcgo.Func) string {
 	return join(fn.Params, func(_ int, p *mkcgo.Param) string {
-		return p.Name + " " + cTypeToGo(p.Type, false)
+		typ, _ := cTypeToGo(p.Type, false)
+		return p.Name + " " + typ
 	}, ", ")
 }