sync with OpenBSD -current

bin/ed/main.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: main.c,v 1.69 2024/07/16 05:01:10 deraadt Exp $	*/
+/*	$OpenBSD: main.c,v 1.70 2024/10/12 07:58:40 jsg Exp $	*/
 /*	$NetBSD: main.c,v 1.3 1995/03/21 09:04:44 cgd Exp $	*/
 
 /* main.c: This file contains the main control and user-interface routines
@@ -44,7 +44,6 @@
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
-#include <unistd.h>
 
 #include <ctype.h>
 #include <err.h>

etc/etc.amd64/login.conf

@@ -1,4 +1,4 @@
-# $OpenBSD: login.conf,v 1.24 2023/11/12 14:41:41 robert Exp $
+# $OpenBSD: login.conf,v 1.25 2024/10/12 07:36:52 robert Exp $
 
 #
 # Sample login.conf file.  See login.conf(5) for details.
@@ -87,6 +87,13 @@ authpf:\
 	:tc=default:
 
 #
+# Building LLVM in base requires higher limits
+#
+build:\
+	:datasize-max=1843M:\
+	:datasize-cur=1843M:\
+	:tc=default:
+
 # Building ports with DPB uses raised limits
 #
 pbuild:\

etc/etc.arm64/login.conf

@@ -1,4 +1,4 @@
-# $OpenBSD: login.conf,v 1.16 2023/11/12 14:41:41 robert Exp $
+# $OpenBSD: login.conf,v 1.17 2024/10/12 07:36:52 robert Exp $
 
 #
 # Sample login.conf file.  See login.conf(5) for details.
@@ -87,6 +87,14 @@ authpf:\
 	:shell=/usr/sbin/authpf:\
 	:tc=default:
 
+#
+# Building LLVM in base requires higher limits
+#
+build:\
+	:datasize-max=1843M:\
+	:datasize-cur=1843M:\
+	:tc=default:
+
 #
 # Building ports with DPB uses raised limits
 #

etc/etc.armv7/login.conf

@@ -1,4 +1,4 @@
-# $OpenBSD: login.conf,v 1.16 2024/08/04 20:06:04 phessler Exp $
+# $OpenBSD: login.conf,v 1.17 2024/10/12 07:36:52 robert Exp $
 
 #
 # Sample login.conf file.  See login.conf(5) for details.
@@ -87,6 +87,14 @@ authpf:\
 	:shell=/usr/sbin/authpf:\
 	:tc=default:
 
+#
+# Building LLVM in base requires higher limits
+#
+build:\
+	:datasize-max=1843M:\
+	:datasize-cur=1843M:\
+	:tc=default:
+
 #
 # Building ports with DPB uses raised limits
 #

etc/etc.i386/login.conf

@@ -1,4 +1,4 @@
-# $OpenBSD: login.conf,v 1.20 2023/12/31 16:05:50 bluhm Exp $
+# $OpenBSD: login.conf,v 1.21 2024/10/12 07:36:52 robert Exp $
 
 #
 # Sample login.conf file.  See login.conf(5) for details.
@@ -86,6 +86,14 @@ authpf:\
 	:shell=/usr/sbin/authpf:\
 	:tc=default:
 
+#
+# Building LLVM in base requires higher limits
+#
+build:\
+	:datasize-max=1843M:\
+	:datasize-cur=1843M:\
+	:tc=default:
+
 #
 # Building ports with DPB uses raised limits
 #

lib/libc/sys/sysctl.2

@@ -1,4 +1,4 @@
-.\"	$OpenBSD: sysctl.2,v 1.57 2023/10/14 19:02:16 kettenis Exp $
+.\"	$OpenBSD: sysctl.2,v 1.58 2024/10/10 22:21:05 lucas Exp $
 .\"
 .\" Copyright (c) 1993
 .\"	The Regents of the University of California.  All rights reserved.
@@ -27,7 +27,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.Dd $Mdocdate: October 14 2023 $
+.Dd $Mdocdate: October 10 2024 $
 .Dt SYSCTL 2
 .Os
 .Sh NAME
@@ -1322,7 +1322,7 @@ priority value.
 .Pp
 An optional seventh level name can be provided to select the routing table
 on which to run the operation.
-If not provided, the table with ID 0 is used.
+If not provided, the current routing table is used.
 .It Dv PF_INET
 Get or set various global information about IPv4
 .Pq Internet Protocol version 4 .

lib/libcrypto/ec/ec_asn1.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_asn1.c,v 1.57 2024/10/03 05:07:49 tb Exp $ */
+/* $OpenBSD: ec_asn1.c,v 1.68 2024/10/11 18:58:04 tb Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -124,6 +124,10 @@ typedef struct ec_parameters_st {
 	ASN1_INTEGER *cofactor;
 } ECPARAMETERS;
 
+#define ECPK_PARAM_NAMED_CURVE		0
+#define ECPK_PARAM_EXPLICIT		1
+#define ECPK_PARAM_IMPLICITLY_CA	2
+
 typedef struct ecpk_parameters_st {
 	int type;
 	union {
@@ -555,56 +559,52 @@ EC_PRIVATEKEY_free(EC_PRIVATEKEY *a)
 static int
 ec_asn1_group2fieldid(const EC_GROUP *group, X9_62_FIELDID *field)
 {
-	int ok = 0, nid;
+	BIGNUM *p = NULL;
-	BIGNUM *tmp = NULL;
+	int nid;
+	int ret = 0;
 
 	if (group == NULL || field == NULL)
-		return 0;
+		goto err;
-
-	/* clear the old values (if necessary) */
-	if (field->fieldType != NULL)
-		ASN1_OBJECT_free(field->fieldType);
-	if (field->p.other != NULL)
-		ASN1_TYPE_free(field->p.other);
 
 	nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group));
-	/* set OID for the field */
+	if (nid == NID_X9_62_characteristic_two_field) {
+		ECerror(EC_R_GF2M_NOT_SUPPORTED);
+		goto err;
+	}
+	if (nid != NID_X9_62_prime_field) {
+		ECerror(EC_R_INVALID_FIELD);
+		goto err;
+	}
+
 	if ((field->fieldType = OBJ_nid2obj(nid)) == NULL) {
 		ECerror(ERR_R_OBJ_LIB);
 		goto err;
 	}
-	if (nid == NID_X9_62_prime_field) {
+	if ((p = BN_new()) == NULL) {
-		if ((tmp = BN_new()) == NULL) {
+		ECerror(ERR_R_MALLOC_FAILURE);
-			ECerror(ERR_R_MALLOC_FAILURE);
+		goto err;
-			goto err;
+	}
-		}
+	if (!EC_GROUP_get_curve(group, p, NULL, NULL, NULL)) {
-		/* the parameters are specified by the prime number p */
+		ECerror(ERR_R_EC_LIB);
-		if (!EC_GROUP_get_curve(group, tmp, NULL, NULL, NULL)) {
+		goto err;
-			ECerror(ERR_R_EC_LIB);
+	}
-			goto err;
+	if ((field->p.prime = BN_to_ASN1_INTEGER(p, NULL)) == NULL) {
-		}
+		ECerror(ERR_R_ASN1_LIB);
-		/* set the prime number */
-		field->p.prime = BN_to_ASN1_INTEGER(tmp, NULL);
-		if (field->p.prime == NULL) {
-			ECerror(ERR_R_ASN1_LIB);
-			goto err;
-		}
-	} else {
-		ECerror(EC_R_GF2M_NOT_SUPPORTED);
 		goto err;
 	}
 
-	ok = 1;
+	ret = 1;
 
  err:
-	BN_free(tmp);
+	BN_free(p);
-	return (ok);
+
+	return ret;
 }
 
 static int
 ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
 {
-	BIGNUM *tmp_1 = NULL, *tmp_2 = NULL;
+	BIGNUM *a = NULL, *b = NULL;
 	unsigned char *buffer_1 = NULL, *buffer_2 = NULL, *a_buf = NULL,
 	*b_buf = NULL;
 	size_t len_1, len_2;
@@ -614,18 +614,18 @@ ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
 	if (!group || !curve || !curve->a || !curve->b)
 		return 0;
 
-	if ((tmp_1 = BN_new()) == NULL || (tmp_2 = BN_new()) == NULL) {
+	if ((a = BN_new()) == NULL || (b = BN_new()) == NULL) {
 		ECerror(ERR_R_MALLOC_FAILURE);
 		goto err;
 	}
 
 	/* get a and b */
-	if (!EC_GROUP_get_curve(group, NULL, tmp_1, tmp_2, NULL)) {
+	if (!EC_GROUP_get_curve(group, NULL, a, b, NULL)) {
 		ECerror(ERR_R_EC_LIB);
 		goto err;
 	}
-	len_1 = (size_t) BN_num_bytes(tmp_1);
+	len_1 = (size_t) BN_num_bytes(a);
-	len_2 = (size_t) BN_num_bytes(tmp_2);
+	len_2 = (size_t) BN_num_bytes(b);
 
 	if (len_1 == 0) {
 		/* len_1 == 0 => a == 0 */
@@ -636,7 +636,7 @@ ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
 			ECerror(ERR_R_MALLOC_FAILURE);
 			goto err;
 		}
-		if ((len_1 = BN_bn2bin(tmp_1, buffer_1)) == 0) {
+		if ((len_1 = BN_bn2bin(a, buffer_1)) == 0) {
 			ECerror(ERR_R_BN_LIB);
 			goto err;
 		}
@@ -652,7 +652,7 @@ ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
 			ECerror(ERR_R_MALLOC_FAILURE);
 			goto err;
 		}
-		if ((len_2 = BN_bn2bin(tmp_2, buffer_2)) == 0) {
+		if ((len_2 = BN_bn2bin(b, buffer_2)) == 0) {
 			ECerror(ERR_R_BN_LIB);
 			goto err;
 		}
@@ -691,13 +691,14 @@ ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
  err:
 	free(buffer_1);
 	free(buffer_2);
-	BN_free(tmp_1);
+	BN_free(a);
-	BN_free(tmp_2);
+	BN_free(b);
+
 	return (ok);
 }
 
 static ECPARAMETERS *
-ec_asn1_group2parameters(const EC_GROUP *group, ECPARAMETERS *param)
+ec_asn1_group2parameters(const EC_GROUP *group)
 {
 	int ok = 0;
 	size_t len = 0;
@@ -711,13 +712,10 @@ ec_asn1_group2parameters(const EC_GROUP *group, ECPARAMETERS *param)
 		ECerror(ERR_R_MALLOC_FAILURE);
 		goto err;
 	}
-	if (param == NULL) {
+	if ((ret = ECPARAMETERS_new()) == NULL) {
-		if ((ret = ECPARAMETERS_new()) == NULL) {
+		ECerror(ERR_R_MALLOC_FAILURE);
-			ECerror(ERR_R_MALLOC_FAILURE);
+		goto err;
-			goto err;
+	}
-		}
-	} else
-		ret = param;
 
 	/* set the version (always one) */
 	ret->version = (long) 0x1;
@@ -781,8 +779,7 @@ ec_asn1_group2parameters(const EC_GROUP *group, ECPARAMETERS *param)
 
  err:
 	if (!ok) {
-		if (ret && !param)
+		ECPARAMETERS_free(ret);
-			ECPARAMETERS_free(ret);
 		ret = NULL;
 	}
 	BN_free(tmp);
@@ -791,49 +788,39 @@ ec_asn1_group2parameters(const EC_GROUP *group, ECPARAMETERS *param)
 }
 
 ECPKPARAMETERS *
-ec_asn1_group2pkparameters(const EC_GROUP *group, ECPKPARAMETERS *params)
+ec_asn1_group2pkparameters(const EC_GROUP *group)
 {
-	int ok = 1, tmp;
+	ECPKPARAMETERS *pkparameters;
-	ECPKPARAMETERS *ret = params;
+	ECPARAMETERS *parameters;
+	ASN1_OBJECT *aobj;
+	int nid;
 
-	if (ret == NULL) {
+	if ((pkparameters = ECPKPARAMETERS_new()) == NULL) {
-		if ((ret = ECPKPARAMETERS_new()) == NULL) {
+		ECerror(ERR_R_MALLOC_FAILURE);
-			ECerror(ERR_R_MALLOC_FAILURE);
+		goto err;
-			return NULL;
+	}
-		}
+
+	if ((EC_GROUP_get_asn1_flag(group) & OPENSSL_EC_NAMED_CURVE) != 0) {
+		if ((nid = EC_GROUP_get_curve_name(group)) == NID_undef)
+			goto err;
+		if ((aobj = OBJ_nid2obj(nid)) == NULL)
+			goto err;
+		pkparameters->type = ECPK_PARAM_NAMED_CURVE;
+		pkparameters->value.named_curve = aobj;
 	} else {
-		if (ret->type == 0 && ret->value.named_curve)
+		if ((parameters = ec_asn1_group2parameters(group)) == NULL)
-			ASN1_OBJECT_free(ret->value.named_curve);
+			goto err;
-		else if (ret->type == 1 && ret->value.parameters)
+		pkparameters->type = ECPK_PARAM_EXPLICIT;
-			ECPARAMETERS_free(ret->value.parameters);
+		pkparameters->value.parameters = parameters;
+		parameters = NULL;
 	}
 
-	if (EC_GROUP_get_asn1_flag(group)) {
+	return pkparameters;
-		/*
-		 * use the asn1 OID to describe the elliptic curve
-		 * parameters
-		 */
-		tmp = EC_GROUP_get_curve_name(group);
-		if (tmp) {
-			ret->type = 0;
-			if ((ret->value.named_curve = OBJ_nid2obj(tmp)) == NULL)
-				ok = 0;
-		} else
-			/* we don't know the group => ERROR */
-			ok = 0;
-	} else {
-		/* use the ECPARAMETERS structure */
-		ret->type = 1;
-		if ((ret->value.parameters = ec_asn1_group2parameters(group,
-		    NULL)) == NULL)
-			ok = 0;
-	}
 
-	if (!ok) {
+ err:
-		ECPKPARAMETERS_free(ret);
+	ECPKPARAMETERS_free(pkparameters);
-		return NULL;
+
-	}
+	return NULL;
-	return ret;
 }
 
 static EC_GROUP *
@@ -975,36 +962,34 @@ ec_asn1_parameters2group(const ECPARAMETERS *params)
 EC_GROUP *
 ec_asn1_pkparameters2group(const ECPKPARAMETERS *params)
 {
-	EC_GROUP *ret = NULL;
+	EC_GROUP *group;
-	int tmp = 0;
+	int nid;
 
-	if (params == NULL) {
+	if (params->type == ECPK_PARAM_NAMED_CURVE) {
-		ECerror(EC_R_MISSING_PARAMETERS);
+		if ((nid = OBJ_obj2nid(params->value.named_curve)) == NID_undef) {
-		return NULL;
+			ECerror(EC_R_UNKNOWN_GROUP);
-	}
+			return NULL;
-	if (params->type == 0) {/* the curve is given by an OID */
+		}
-		tmp = OBJ_obj2nid(params->value.named_curve);
+		if ((group = EC_GROUP_new_by_curve_name(nid)) == NULL) {
-		if ((ret = EC_GROUP_new_by_curve_name(tmp)) == NULL) {
 			ECerror(EC_R_EC_GROUP_NEW_BY_NAME_FAILURE);
 			return NULL;
 		}
-		EC_GROUP_set_asn1_flag(ret, OPENSSL_EC_NAMED_CURVE);
+		EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
-	} else if (params->type == 1) {	/* the parameters are given by a
+	} else if (params->type == ECPK_PARAM_EXPLICIT) {
-					 * ECPARAMETERS structure */
+		group = ec_asn1_parameters2group(params->value.parameters);
-		ret = ec_asn1_parameters2group(params->value.parameters);
+		if (group == NULL) {
-		if (!ret) {
 			ECerror(ERR_R_EC_LIB);
 			return NULL;
 		}
-		EC_GROUP_set_asn1_flag(ret, 0x0);
+		EC_GROUP_set_asn1_flag(group, 0);
-	} else if (params->type == 2) {	/* implicitlyCA */
+	} else if (params->type == ECPK_PARAM_IMPLICITLY_CA) {
 		return NULL;
 	} else {
 		ECerror(EC_R_ASN1_ERROR);
 		return NULL;
 	}
 
-	return ret;
+	return group;
 }
 
 EC_GROUP *
@@ -1034,21 +1019,24 @@ d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
 LCRYPTO_ALIAS(d2i_ECPKParameters);
 
 int
-i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
+i2d_ECPKParameters(const EC_GROUP *group, unsigned char **out_der)
 {
+	ECPKPARAMETERS *parameters;
 	int ret = 0;
-	ECPKPARAMETERS *tmp = ec_asn1_group2pkparameters(a, NULL);
+
-	if (tmp == NULL) {
+	if ((parameters = ec_asn1_group2pkparameters(group)) == NULL) {
 		ECerror(EC_R_GROUP2PKPARAMETERS_FAILURE);
-		return 0;
+		goto err;
 	}
-	if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0) {
+	if ((ret = i2d_ECPKPARAMETERS(parameters, out_der)) <= 0) {
 		ECerror(EC_R_I2D_ECPKPARAMETERS_FAILURE);
-		ECPKPARAMETERS_free(tmp);
+		goto err;
-		return 0;
 	}
-	ECPKPARAMETERS_free(tmp);
+
-	return (ret);
+ err:
+	ECPKPARAMETERS_free(parameters);
+
+	return ret;
 }
 LCRYPTO_ALIAS(i2d_ECPKParameters);
 
@@ -1179,11 +1167,13 @@ i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
 		goto err;
 	}
 	if (!(a->enc_flag & EC_PKEY_NO_PARAMETERS)) {
-		if ((priv_key->parameters = ec_asn1_group2pkparameters(
+		ECPKPARAMETERS *parameters;
-			    a->group, priv_key->parameters)) == NULL) {
+
+		if ((parameters = ec_asn1_group2pkparameters(a->group)) == NULL) {
 			ECerror(ERR_R_EC_LIB);
 			goto err;
 		}
+		priv_key->parameters = parameters;
 	}
 	if (!(a->enc_flag & EC_PKEY_NO_PUBKEY) && a->pub_key != NULL) {
 		priv_key->publicKey = ASN1_BIT_STRING_new();

lib/libcrypto/err/err.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: err.c,v 1.65 2024/10/02 15:21:39 jsing Exp $ */
+/* $OpenBSD: err.c,v 1.73 2024/10/11 13:32:22 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -127,8 +127,6 @@
 DECLARE_LHASH_OF(ERR_STRING_DATA);
 DECLARE_LHASH_OF(ERR_STATE);
 
-typedef struct st_ERR_FNS ERR_FNS;
-
 typedef struct err_state_st {
 	CRYPTO_THREADID tid;
 	int err_flags[ERR_NUM_ERRORS];
@@ -141,54 +139,54 @@ typedef struct err_state_st {
 } ERR_STATE;
 
 #ifndef OPENSSL_NO_ERR
-static ERR_STRING_DATA ERR_str_libraries[] = {
+static const ERR_STRING_DATA ERR_str_libraries[] = {
-	{ERR_PACK(ERR_LIB_NONE,0,0),		"unknown library"},
+	{ERR_PACK(ERR_LIB_NONE, 0, 0),		"unknown library"},
-	{ERR_PACK(ERR_LIB_SYS,0,0),		"system library"},
+	{ERR_PACK(ERR_LIB_SYS, 0, 0),		"system library"},
-	{ERR_PACK(ERR_LIB_BN,0,0),		"bignum routines"},
+	{ERR_PACK(ERR_LIB_BN, 0, 0),		"bignum routines"},
-	{ERR_PACK(ERR_LIB_RSA,0,0),		"rsa routines"},
+	{ERR_PACK(ERR_LIB_RSA, 0, 0),		"rsa routines"},
-	{ERR_PACK(ERR_LIB_DH,0,0),		"Diffie-Hellman routines"},
+	{ERR_PACK(ERR_LIB_DH, 0, 0),		"Diffie-Hellman routines"},
-	{ERR_PACK(ERR_LIB_EVP,0,0),		"digital envelope routines"},
+	{ERR_PACK(ERR_LIB_EVP, 0, 0),		"digital envelope routines"},
-	{ERR_PACK(ERR_LIB_BUF,0,0),		"memory buffer routines"},
+	{ERR_PACK(ERR_LIB_BUF, 0, 0),		"memory buffer routines"},
-	{ERR_PACK(ERR_LIB_OBJ,0,0),		"object identifier routines"},
+	{ERR_PACK(ERR_LIB_OBJ, 0, 0),		"object identifier routines"},
-	{ERR_PACK(ERR_LIB_PEM,0,0),		"PEM routines"},
+	{ERR_PACK(ERR_LIB_PEM, 0, 0),		"PEM routines"},
-	{ERR_PACK(ERR_LIB_DSA,0,0),		"dsa routines"},
+	{ERR_PACK(ERR_LIB_DSA, 0, 0),		"dsa routines"},
-	{ERR_PACK(ERR_LIB_X509,0,0),		"x509 certificate routines"},
+	{ERR_PACK(ERR_LIB_X509, 0, 0),		"x509 certificate routines"},
-	{ERR_PACK(ERR_LIB_ASN1,0,0),		"asn1 encoding routines"},
+	{ERR_PACK(ERR_LIB_ASN1, 0, 0),		"asn1 encoding routines"},
-	{ERR_PACK(ERR_LIB_CONF,0,0),		"configuration file routines"},
+	{ERR_PACK(ERR_LIB_CONF, 0, 0),		"configuration file routines"},
-	{ERR_PACK(ERR_LIB_CRYPTO,0,0),		"common libcrypto routines"},
+	{ERR_PACK(ERR_LIB_CRYPTO, 0, 0),	"common libcrypto routines"},
-	{ERR_PACK(ERR_LIB_EC,0,0),		"elliptic curve routines"},
+	{ERR_PACK(ERR_LIB_EC, 0, 0),		"elliptic curve routines"},
-	{ERR_PACK(ERR_LIB_SSL,0,0),		"SSL routines"},
+	{ERR_PACK(ERR_LIB_SSL, 0, 0),		"SSL routines"},
-	{ERR_PACK(ERR_LIB_BIO,0,0),		"BIO routines"},
+	{ERR_PACK(ERR_LIB_BIO, 0, 0),		"BIO routines"},
-	{ERR_PACK(ERR_LIB_PKCS7,0,0),		"PKCS7 routines"},
+	{ERR_PACK(ERR_LIB_PKCS7, 0, 0),		"PKCS7 routines"},
-	{ERR_PACK(ERR_LIB_X509V3,0,0),		"X509 V3 routines"},
+	{ERR_PACK(ERR_LIB_X509V3, 0, 0),	"X509 V3 routines"},
-	{ERR_PACK(ERR_LIB_PKCS12,0,0),		"PKCS12 routines"},
+	{ERR_PACK(ERR_LIB_PKCS12, 0, 0),	"PKCS12 routines"},
-	{ERR_PACK(ERR_LIB_RAND,0,0),		"random number generator"},
+	{ERR_PACK(ERR_LIB_RAND, 0, 0),		"random number generator"},
-	{ERR_PACK(ERR_LIB_DSO,0,0),		"DSO support routines"},
+	{ERR_PACK(ERR_LIB_DSO, 0, 0),		"DSO support routines"},
-	{ERR_PACK(ERR_LIB_TS,0,0),		"time stamp routines"},
+	{ERR_PACK(ERR_LIB_TS, 0, 0),		"time stamp routines"},
-	{ERR_PACK(ERR_LIB_ENGINE,0,0),		"engine routines"},
+	{ERR_PACK(ERR_LIB_ENGINE, 0, 0),	"engine routines"},
-	{ERR_PACK(ERR_LIB_OCSP,0,0),		"OCSP routines"},
+	{ERR_PACK(ERR_LIB_OCSP, 0, 0),		"OCSP routines"},
-	{ERR_PACK(ERR_LIB_FIPS,0,0),		"FIPS routines"},
+	{ERR_PACK(ERR_LIB_FIPS, 0, 0),		"FIPS routines"},
-	{ERR_PACK(ERR_LIB_CMS,0,0),		"CMS routines"},
+	{ERR_PACK(ERR_LIB_CMS, 0, 0),		"CMS routines"},
-	{ERR_PACK(ERR_LIB_HMAC,0,0),		"HMAC routines"},
+	{ERR_PACK(ERR_LIB_HMAC, 0, 0),		"HMAC routines"},
-	{ERR_PACK(ERR_LIB_GOST,0,0),		"GOST routines"},
+	{ERR_PACK(ERR_LIB_GOST, 0, 0),		"GOST routines"},
 	{0, NULL},
 };
 
-static ERR_STRING_DATA ERR_str_functs[] = {
+static const ERR_STRING_DATA ERR_str_functs[] = {
-	{ERR_PACK(0,SYS_F_FOPEN, 0),     	"fopen"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_FOPEN, 0),		"fopen"},
-	{ERR_PACK(0,SYS_F_CONNECT, 0),		"connect"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_CONNECT, 0),	"connect"},
-	{ERR_PACK(0,SYS_F_GETSERVBYNAME, 0),	"getservbyname"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_GETSERVBYNAME, 0),	"getservbyname"},
-	{ERR_PACK(0,SYS_F_SOCKET, 0),		"socket"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_SOCKET, 0),	"socket"},
-	{ERR_PACK(0,SYS_F_IOCTLSOCKET, 0),	"ioctl"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_IOCTLSOCKET, 0),	"ioctl"},
-	{ERR_PACK(0,SYS_F_BIND, 0),		"bind"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_BIND, 0),		"bind"},
-	{ERR_PACK(0,SYS_F_LISTEN, 0),		"listen"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_LISTEN, 0),	"listen"},
-	{ERR_PACK(0,SYS_F_ACCEPT, 0),		"accept"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_ACCEPT, 0),	"accept"},
-	{ERR_PACK(0,SYS_F_OPENDIR, 0),		"opendir"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_OPENDIR, 0),	"opendir"},
-	{ERR_PACK(0,SYS_F_FREAD, 0),		"fread"},
+	{ERR_PACK(ERR_LIB_SYS, SYS_F_FREAD, 0),		"fread"},
 	{0, NULL},
 };
 
-static ERR_STRING_DATA ERR_str_reasons[] = {
+static const ERR_STRING_DATA ERR_str_reasons[] = {
 	{ERR_R_SYS_LIB,				"system lib"},
 	{ERR_R_BN_LIB,				"BN lib"},
 	{ERR_R_RSA_LIB,				"RSA lib"},
@@ -226,7 +224,7 @@ static ERR_STRING_DATA ERR_str_reasons[] = {
 	{ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,	"called a function you should not call"},
 	{ERR_R_PASSED_NULL_PARAMETER,		"passed a null parameter"},
 	{ERR_R_INTERNAL_ERROR,			"internal error"},
-	{ERR_R_DISABLED	,			"called a function that was disabled at compile-time"},
+	{ERR_R_DISABLED,			"called a function that was disabled at compile-time"},
 	{ERR_R_INIT_FAIL,			"initialization failure"},
 
 	{0, NULL},
@@ -254,8 +252,6 @@ static pthread_t err_init_thread;
  * internal to the "err_defaults" implementation.
  */
 
-/* The internal functions used in the "err_defaults" implementation */
-
 static unsigned long
 err_string_data_hash(const ERR_STRING_DATA *a)
 {
@@ -475,36 +471,23 @@ err_get_next_lib(void)
 #define LEN_SYS_STR_REASON 32
 
 static ERR_STRING_DATA SYS_str_reasons[NUM_SYS_STR_REASONS + 1];
-/* SYS_str_reasons is filled with copies of strerror() results at
+
- * initialization.
+/*
- * 'errno' values up to 127 should cover all usual errors,
+ * SYS_str_reasons is filled with copies of strerror() results at
- * others will be displayed numerically by ERR_error_string.
+ * initialization. 'errno' values up to 127 should cover all usual errors,
- * It is crucial that we have something for each reason code
+ * others will be displayed numerically by ERR_error_string. It is crucial that
- * that occurs in ERR_str_reasons, or bogus reason strings
+ * we have something for each reason code that occurs in ERR_str_reasons, or
- * will be returned for SYSerror(which always gets an errno
+ * bogus reason strings will be returned for SYSerror(), which always gets an
- * value and never one of those 'standard' reason codes. */
+ * errno value and never one of those 'standard' reason codes.
+ */
 
 static void
-build_SYS_str_reasons(void)
+err_build_SYS_str_reasons(void)
 {
 	/* malloc cannot be used here, use static storage instead */
 	static char strerror_tab[NUM_SYS_STR_REASONS][LEN_SYS_STR_REASON];
-	int i;
-	static int init = 1;
 	int save_errno;
-
+	int i;
-	CRYPTO_r_lock(CRYPTO_LOCK_ERR);
-	if (!init) {
-		CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
-		return;
-	}
-
-	CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
-	CRYPTO_w_lock(CRYPTO_LOCK_ERR);
-	if (!init) {
-		CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
-		return;
-	}
 
 	/* strerror(3) will set errno to EINVAL when i is an unknown errno. */
 	save_errno = errno;
@@ -526,33 +509,33 @@ build_SYS_str_reasons(void)
 	}
 	errno = save_errno;
 
-	/* Now we still have SYS_str_reasons[NUM_SYS_STR_REASONS] = {0, NULL},
+	/*
-	 * as required by ERR_load_strings. */
+	 * Now we still have SYS_str_reasons[NUM_SYS_STR_REASONS] = {0, NULL},
-
+	 * as required by ERR_load_strings.
-	init = 0;
+	 */
-
-	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
 }
 #endif
 
-#define err_clear_data(p,i) \
+static void
-	do { \
+err_clear_data(ERR_STATE *s, int i)
-		if (((p)->err_data[i] != NULL) && \
+{
-		    (p)->err_data_flags[i] & ERR_TXT_MALLOCED) { \
+	if ((s->err_data_flags[i] & ERR_TXT_MALLOCED) != 0)
-			free((p)->err_data[i]); \
+		free(s->err_data[i]);
-			(p)->err_data[i] = NULL; \
-		} \
-		(p)->err_data_flags[i] = 0; \
-	} while(0)
 
-#define err_clear(p,i) \
+	s->err_data[i] = NULL;
-	do { \
+	s->err_data_flags[i] = 0;
-		(p)->err_flags[i] = 0; \
+}
-		(p)->err_buffer[i] = 0; \
+
-		err_clear_data(p, i); \
+static void
-		(p)->err_file[i] = NULL; \
+err_clear(ERR_STATE *s, int i)
-		(p)->err_line[i] = -1; \
+{
-	} while(0)
+	s->err_flags[i] = 0;
+	s->err_buffer[i] = 0;
+	s->err_file[i] = NULL;
+	s->err_line[i] = -1;
+
+	err_clear_data(s, i);
+}
 
 static void
 ERR_STATE_free(ERR_STATE *s)
@@ -562,9 +545,9 @@ ERR_STATE_free(ERR_STATE *s)
 	if (s == NULL)
 		return;
 
-	for (i = 0; i < ERR_NUM_ERRORS; i++) {
+	for (i = 0; i < ERR_NUM_ERRORS; i++)
 		err_clear_data(s, i);
-	}
+
 	free(s);
 }
 
@@ -598,8 +581,10 @@ ERR_get_state(void)
 			ERR_STATE_free(ret); /* could not insert it */
 			return (&fallback);
 		}
-		/* If a race occurred in this function and we came second, tmpp
+		/*
-		 * is the first one that we just replaced. */
+		 * If a race occurred in this function and we came second,
+		 * tmpp is the first one that we just replaced.
+		 */
 		if (tmpp)
 			ERR_STATE_free(tmpp);
 	}
@@ -609,7 +594,7 @@ ERR_get_state(void)
 static void
 err_load_strings(int lib, ERR_STRING_DATA *str)
 {
-	while (str->error) {
+	while (str->error != 0) {
 		if (lib)
 			str->error |= ERR_PACK(lib, 0, 0);
 		err_set_item(str);
@@ -617,6 +602,15 @@ err_load_strings(int lib, ERR_STRING_DATA *str)
 	}
 }
 
+static void
+err_load_const_strings(const ERR_STRING_DATA *str)
+{
+	while (str->error != 0) {
+		err_set_item(str);
+		str++;
+	}
+}
+
 static unsigned long
 get_error_values(int inc, int top, const char **file, int *line,
     const char **data, int *flags)
@@ -688,10 +682,10 @@ ERR_load_ERR_strings_internal(void)
 {
 	err_init_thread = pthread_self();
 #ifndef OPENSSL_NO_ERR
-	err_load_strings(0, ERR_str_libraries);
+	err_load_const_strings(ERR_str_libraries);
-	err_load_strings(0, ERR_str_reasons);
+	err_load_const_strings(ERR_str_reasons);
-	err_load_strings(ERR_LIB_SYS, ERR_str_functs);
+	err_load_const_strings(ERR_str_functs);
-	build_SYS_str_reasons();
+	err_build_SYS_str_reasons();
 	err_load_strings(ERR_LIB_SYS, SYS_str_reasons);
 #endif
 }
@@ -723,10 +717,7 @@ void
 ERR_load_const_strings(const ERR_STRING_DATA *str)
 {
 	ERR_load_ERR_strings();
-	while (str->error) {
+	err_load_const_strings(str);
-		err_set_item(str);
-		str++;
-	}
 }
 
 void
@@ -770,8 +761,11 @@ ERR_remove_thread_state(const CRYPTO_THREADID *id)
 		CRYPTO_THREADID_cpy(&tmp.tid, id);
 	else
 		CRYPTO_THREADID_current(&tmp.tid);
-	/* err_thread_del_item automatically destroys the LHASH if the number of
+
-	 * items reaches zero. */
+	/*
+	 * err_thread_del_item automatically destroys the LHASH if the number of
+	 * items reaches zero.
+	 */
 	err_thread_del_item(&tmp);
 }
 LCRYPTO_ALIAS(ERR_remove_thread_state);
@@ -827,9 +821,9 @@ ERR_clear_error(void)
 
 	es = ERR_get_state();
 
-	for (i = 0; i < ERR_NUM_ERRORS; i++) {
+	for (i = 0; i < ERR_NUM_ERRORS; i++)
 		err_clear(es, i);
-	}
+
 	es->top = es->bottom = 0;
 }
 LCRYPTO_ALIAS(ERR_clear_error);
@@ -1059,8 +1053,10 @@ ERR_error_string_n(unsigned long e, char *buf, size_t len)
 	if (ret == -1)
 		return;	/* can't happen, and can't do better if it does */
 	if (ret >= len) {
-		/* output may be truncated; make sure we always have 5
+		/*
-		 * colon-separated fields, i.e. 4 colons ... */
+		 * output may be truncated; make sure we always have 5
+		 * colon-separated fields, i.e. 4 colons ...
+		 */
 #define NUM_COLONS 4
 		if (len > NUM_COLONS) /* ... if possible */
 		{
@@ -1083,9 +1079,12 @@ ERR_error_string_n(unsigned long e, char *buf, size_t len)
 }
 LCRYPTO_ALIAS(ERR_error_string_n);
 
-/* BAD for multi-threading: uses a local buffer if ret == NULL */
+/*
-/* ERR_error_string_n should be used instead for ret != NULL
+ * ERR_error_string_n should be used instead for ret != NULL
- * as ERR_error_string cannot know how large the buffer is */
+ * as ERR_error_string cannot know how large the buffer is.
+ *
+ * BAD for multi-threading: uses a local buffer if ret == NULL.
+ */
 char *
 ERR_error_string(unsigned long e, char *ret)
 {

lib/libssl/ssl_stat.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_stat.c,v 1.22 2024/10/09 08:01:39 tb Exp $ */
+/* $OpenBSD: ssl_stat.c,v 1.23 2024/10/12 03:54:18 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -89,465 +89,323 @@
 const char *
 SSL_state_string_long(const SSL *s)
 {
-	const char *str;
-
 	switch (s->s3->hs.state) {
 	case SSL_ST_BEFORE:
-		str = "before SSL initialization";
+		return "before SSL initialization";
-		break;
 	case SSL_ST_ACCEPT:
-		str = "before accept initialization";
+		return "before accept initialization";
-		break;
 	case SSL_ST_CONNECT:
-		str = "before connect initialization";
+		return "before connect initialization";
-		break;
 	case SSL_ST_OK:
-		str = "SSL negotiation finished successfully";
+		return "SSL negotiation finished successfully";
-		break;
 	case SSL_ST_RENEGOTIATE:
-		str = "SSL renegotiate ciphers";
+		return "SSL renegotiate ciphers";
-		break;
 	case SSL_ST_BEFORE|SSL_ST_CONNECT:
-		str = "before/connect initialization";
+		return "before/connect initialization";
-		break;
 	case SSL_ST_OK|SSL_ST_CONNECT:
-		str = "ok/connect SSL initialization";
+		return "ok/connect SSL initialization";
-		break;
 	case SSL_ST_BEFORE|SSL_ST_ACCEPT:
-		str = "before/accept initialization";
+		return "before/accept initialization";
-		break;
 	case SSL_ST_OK|SSL_ST_ACCEPT:
-		str = "ok/accept SSL initialization";
+		return "ok/accept SSL initialization";
-		break;
 
 	/* SSLv3 additions */
 	case SSL3_ST_CW_CLNT_HELLO_A:
-		str = "SSLv3 write client hello A";
+		return "SSLv3 write client hello A";
-		break;
 	case SSL3_ST_CW_CLNT_HELLO_B:
-		str = "SSLv3 write client hello B";
+		return "SSLv3 write client hello B";
-		break;
 	case SSL3_ST_CR_SRVR_HELLO_A:
-		str = "SSLv3 read server hello A";
+		return "SSLv3 read server hello A";
-		break;
 	case SSL3_ST_CR_SRVR_HELLO_B:
-		str = "SSLv3 read server hello B";
+		return "SSLv3 read server hello B";
-		break;
 	case SSL3_ST_CR_CERT_A:
-		str = "SSLv3 read server certificate A";
+		return "SSLv3 read server certificate A";
-		break;
 	case SSL3_ST_CR_CERT_B:
-		str = "SSLv3 read server certificate B";
+		return "SSLv3 read server certificate B";
-		break;
 	case SSL3_ST_CR_KEY_EXCH_A:
-		str = "SSLv3 read server key exchange A";
+		return "SSLv3 read server key exchange A";
-		break;
 	case SSL3_ST_CR_KEY_EXCH_B:
-		str = "SSLv3 read server key exchange B";
+		return "SSLv3 read server key exchange B";
-		break;
 	case SSL3_ST_CR_CERT_REQ_A:
-		str = "SSLv3 read server certificate request A";
+		return "SSLv3 read server certificate request A";
-		break;
 	case SSL3_ST_CR_CERT_REQ_B:
-		str = "SSLv3 read server certificate request B";
+		return "SSLv3 read server certificate request B";
-		break;
 	case SSL3_ST_CR_SESSION_TICKET_A:
-		str = "SSLv3 read server session ticket A";
+		return "SSLv3 read server session ticket A";
-		break;
 	case SSL3_ST_CR_SESSION_TICKET_B:
-		str = "SSLv3 read server session ticket B";
+		return "SSLv3 read server session ticket B";
-		break;
 	case SSL3_ST_CR_SRVR_DONE_A:
-		str = "SSLv3 read server done A";
+		return "SSLv3 read server done A";
-		break;
 	case SSL3_ST_CR_SRVR_DONE_B:
-		str = "SSLv3 read server done B";
+		return "SSLv3 read server done B";
-		break;
 	case SSL3_ST_CW_CERT_A:
-		str = "SSLv3 write client certificate A";
+		return "SSLv3 write client certificate A";
-		break;
 	case SSL3_ST_CW_CERT_B:
-		str = "SSLv3 write client certificate B";
+		return "SSLv3 write client certificate B";
-		break;
 	case SSL3_ST_CW_CERT_C:
-		str = "SSLv3 write client certificate C";
+		return "SSLv3 write client certificate C";
-		break;
 	case SSL3_ST_CW_CERT_D:
-		str = "SSLv3 write client certificate D";
+		return "SSLv3 write client certificate D";
-		break;
 	case SSL3_ST_CW_KEY_EXCH_A:
-		str = "SSLv3 write client key exchange A";
+		return "SSLv3 write client key exchange A";
-		break;
 	case SSL3_ST_CW_KEY_EXCH_B:
-		str = "SSLv3 write client key exchange B";
+		return "SSLv3 write client key exchange B";
-		break;
 	case SSL3_ST_CW_CERT_VRFY_A:
-		str = "SSLv3 write certificate verify A";
+		return "SSLv3 write certificate verify A";
-		break;
 	case SSL3_ST_CW_CERT_VRFY_B:
-		str = "SSLv3 write certificate verify B";
+		return "SSLv3 write certificate verify B";
-		break;
 
 	case SSL3_ST_CW_CHANGE_A:
 	case SSL3_ST_SW_CHANGE_A:
-		str = "SSLv3 write change cipher spec A";
+		return "SSLv3 write change cipher spec A";
-		break;
 	case SSL3_ST_CW_CHANGE_B:
 	case SSL3_ST_SW_CHANGE_B:
-		str = "SSLv3 write change cipher spec B";
+		return "SSLv3 write change cipher spec B";
-		break;
 	case SSL3_ST_CW_FINISHED_A:
 	case SSL3_ST_SW_FINISHED_A:
-		str = "SSLv3 write finished A";
+		return "SSLv3 write finished A";
-		break;
 	case SSL3_ST_CW_FINISHED_B:
 	case SSL3_ST_SW_FINISHED_B:
-		str = "SSLv3 write finished B";
+		return "SSLv3 write finished B";
-		break;
 	case SSL3_ST_CR_CHANGE_A:
 	case SSL3_ST_SR_CHANGE_A:
-		str = "SSLv3 read change cipher spec A";
+		return "SSLv3 read change cipher spec A";
-		break;
 	case SSL3_ST_CR_CHANGE_B:
 	case SSL3_ST_SR_CHANGE_B:
-		str = "SSLv3 read change cipher spec B";
+		return "SSLv3 read change cipher spec B";
-		break;
 	case SSL3_ST_CR_FINISHED_A:
 	case SSL3_ST_SR_FINISHED_A:
-		str = "SSLv3 read finished A";
+		return "SSLv3 read finished A";
-		break;
 	case SSL3_ST_CR_FINISHED_B:
 	case SSL3_ST_SR_FINISHED_B:
-		str = "SSLv3 read finished B";
+		return "SSLv3 read finished B";
-		break;
 
 	case SSL3_ST_CW_FLUSH:
 	case SSL3_ST_SW_FLUSH:
-		str = "SSLv3 flush data";
+		return "SSLv3 flush data";
-		break;
 
 	case SSL3_ST_SR_CLNT_HELLO_A:
-		str = "SSLv3 read client hello A";
+		return "SSLv3 read client hello A";
-		break;
 	case SSL3_ST_SR_CLNT_HELLO_B:
-		str = "SSLv3 read client hello B";
+		return "SSLv3 read client hello B";
-		break;
 	case SSL3_ST_SR_CLNT_HELLO_C:
-		str = "SSLv3 read client hello C";
+		return "SSLv3 read client hello C";
-		break;
 	case SSL3_ST_SW_HELLO_REQ_A:
-		str = "SSLv3 write hello request A";
+		return "SSLv3 write hello request A";
-		break;
 	case SSL3_ST_SW_HELLO_REQ_B:
-		str = "SSLv3 write hello request B";
+		return "SSLv3 write hello request B";
-		break;
 	case SSL3_ST_SW_HELLO_REQ_C:
-		str = "SSLv3 write hello request C";
+		return "SSLv3 write hello request C";
-		break;
 	case SSL3_ST_SW_SRVR_HELLO_A:
-		str = "SSLv3 write server hello A";
+		return "SSLv3 write server hello A";
-		break;
 	case SSL3_ST_SW_SRVR_HELLO_B:
-		str = "SSLv3 write server hello B";
+		return "SSLv3 write server hello B";
-		break;
 	case SSL3_ST_SW_CERT_A:
-		str = "SSLv3 write certificate A";
+		return "SSLv3 write certificate A";
-		break;
 	case SSL3_ST_SW_CERT_B:
-		str = "SSLv3 write certificate B";
+		return "SSLv3 write certificate B";
-		break;
 	case SSL3_ST_SW_KEY_EXCH_A:
-		str = "SSLv3 write key exchange A";
+		return "SSLv3 write key exchange A";
-		break;
 	case SSL3_ST_SW_KEY_EXCH_B:
-		str = "SSLv3 write key exchange B";
+		return "SSLv3 write key exchange B";
-		break;
 	case SSL3_ST_SW_CERT_REQ_A:
-		str = "SSLv3 write certificate request A";
+		return "SSLv3 write certificate request A";
-		break;
 	case SSL3_ST_SW_CERT_REQ_B:
-		str = "SSLv3 write certificate request B";
+		return "SSLv3 write certificate request B";
-		break;
 	case SSL3_ST_SW_SESSION_TICKET_A:
-		str = "SSLv3 write session ticket A";
+		return "SSLv3 write session ticket A";
-		break;
 	case SSL3_ST_SW_SESSION_TICKET_B:
-		str = "SSLv3 write session ticket B";
+		return "SSLv3 write session ticket B";
-		break;
 	case SSL3_ST_SW_SRVR_DONE_A:
-		str = "SSLv3 write server done A";
+		return "SSLv3 write server done A";
-		break;
 	case SSL3_ST_SW_SRVR_DONE_B:
-		str = "SSLv3 write server done B";
+		return "SSLv3 write server done B";
-		break;
 	case SSL3_ST_SR_CERT_A:
-		str = "SSLv3 read client certificate A";
+		return "SSLv3 read client certificate A";
-		break;
 	case SSL3_ST_SR_CERT_B:
-		str = "SSLv3 read client certificate B";
+		return "SSLv3 read client certificate B";
-		break;
 	case SSL3_ST_SR_KEY_EXCH_A:
-		str = "SSLv3 read client key exchange A";
+		return "SSLv3 read client key exchange A";
-		break;
 	case SSL3_ST_SR_KEY_EXCH_B:
-		str = "SSLv3 read client key exchange B";
+		return "SSLv3 read client key exchange B";
-		break;
 	case SSL3_ST_SR_CERT_VRFY_A:
-		str = "SSLv3 read certificate verify A";
+		return "SSLv3 read certificate verify A";
-		break;
 	case SSL3_ST_SR_CERT_VRFY_B:
-		str = "SSLv3 read certificate verify B";
+		return "SSLv3 read certificate verify B";
-		break;
 
 	/* DTLS */
 	case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A:
-		str = "DTLS1 read hello verify request A";
+		return "DTLS1 read hello verify request A";
-		break;
 	case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B:
-		str = "DTLS1 read hello verify request B";
+		return "DTLS1 read hello verify request B";
-		break;
 	case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:
-		str = "DTLS1 write hello verify request A";
+		return "DTLS1 write hello verify request A";
-		break;
 	case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:
-		str = "DTLS1 write hello verify request B";
+		return "DTLS1 write hello verify request B";
-		break;
 
 	default:
-		str = "unknown state";
+		return "unknown state";
-		break;
 	}
-	return (str);
 }
 LSSL_ALIAS(SSL_state_string_long);
 
 const char *
 SSL_rstate_string_long(const SSL *s)
 {
-	const char *str;
-
 	switch (s->rstate) {
 	case SSL_ST_READ_HEADER:
-		str = "read header";
+		return "read header";
-		break;
 	case SSL_ST_READ_BODY:
-		str = "read body";
+		return "read body";
-		break;
 	case SSL_ST_READ_DONE:
-		str = "read done";
+		return "read done";
-		break;
 	default:
-		str = "unknown";
+		return "unknown";
-		break;
 	}
-	return (str);
 }
 LSSL_ALIAS(SSL_rstate_string_long);
 
 const char *
 SSL_state_string(const SSL *s)
 {
-	const char *str;
-
 	switch (s->s3->hs.state) {
 	case SSL_ST_BEFORE:
-		str = "PINIT ";
+		return "PINIT ";
-		break;
 	case SSL_ST_ACCEPT:
-		str = "AINIT ";
+		return "AINIT ";
-		break;
 	case SSL_ST_CONNECT:
-		str = "CINIT ";
+		return "CINIT ";
-		break;
 	case SSL_ST_OK:
-		str = "SSLOK ";
+		return "SSLOK ";
-		break;
 
 	/* SSLv3 additions */
 	case SSL3_ST_SW_FLUSH:
 	case SSL3_ST_CW_FLUSH:
-		str = "3FLUSH";
+		return "3FLUSH";
-		break;
 	case SSL3_ST_CW_CLNT_HELLO_A:
-		str = "3WCH_A";
+		return "3WCH_A";
-		break;
 	case SSL3_ST_CW_CLNT_HELLO_B:
-		str = "3WCH_B";
+		return "3WCH_B";
-		break;
 	case SSL3_ST_CR_SRVR_HELLO_A:
-		str = "3RSH_A";
+		return "3RSH_A";
-		break;
 	case SSL3_ST_CR_SRVR_HELLO_B:
-		str = "3RSH_B";
+		return "3RSH_B";
-		break;
 	case SSL3_ST_CR_CERT_A:
-		str = "3RSC_A";
+		return "3RSC_A";
-		break;
 	case SSL3_ST_CR_CERT_B:
-		str = "3RSC_B";
+		return "3RSC_B";
-		break;
 	case SSL3_ST_CR_KEY_EXCH_A:
-		str = "3RSKEA";
+		return "3RSKEA";
-		break;
 	case SSL3_ST_CR_KEY_EXCH_B:
-		str = "3RSKEB";
+		return "3RSKEB";
-		break;
 	case SSL3_ST_CR_CERT_REQ_A:
-		str = "3RCR_A";
+		return "3RCR_A";
-		break;
 	case SSL3_ST_CR_CERT_REQ_B:
-		str = "3RCR_B";
+		return "3RCR_B";
-		break;
 	case SSL3_ST_CR_SRVR_DONE_A:
-		str = "3RSD_A";
+		return "3RSD_A";
-		break;
 	case SSL3_ST_CR_SRVR_DONE_B:
-		str = "3RSD_B";
+		return "3RSD_B";
-		break;
 	case SSL3_ST_CW_CERT_A:
-		str = "3WCC_A";
+		return "3WCC_A";
-		break;
 	case SSL3_ST_CW_CERT_B:
-		str = "3WCC_B";
+		return "3WCC_B";
-		break;
 	case SSL3_ST_CW_CERT_C:
-		str = "3WCC_C";
+		return "3WCC_C";
-		break;
 	case SSL3_ST_CW_CERT_D:
-		str = "3WCC_D";
+		return "3WCC_D";
-		break;
 	case SSL3_ST_CW_KEY_EXCH_A:
-		str = "3WCKEA";
+		return "3WCKEA";
-		break;
 	case SSL3_ST_CW_KEY_EXCH_B:
-		str = "3WCKEB";
+		return "3WCKEB";
-		break;
 	case SSL3_ST_CW_CERT_VRFY_A:
-		str = "3WCV_A";
+		return "3WCV_A";
-		break;
 	case SSL3_ST_CW_CERT_VRFY_B:
-		str = "3WCV_B";
+		return "3WCV_B";
-		break;
 
 	case SSL3_ST_SW_CHANGE_A:
 	case SSL3_ST_CW_CHANGE_A:
-		str = "3WCCSA";
+		return "3WCCSA";
-		break;
 	case SSL3_ST_SW_CHANGE_B:
 	case SSL3_ST_CW_CHANGE_B:
-		str = "3WCCSB";
+		return "3WCCSB";
-		break;
 	case SSL3_ST_SW_FINISHED_A:
 	case SSL3_ST_CW_FINISHED_A:
-		str = "3WFINA";
+		return "3WFINA";
-		break;
 	case SSL3_ST_SW_FINISHED_B:
 	case SSL3_ST_CW_FINISHED_B:
-		str = "3WFINB";
+		return "3WFINB";
-		break;
 	case SSL3_ST_SR_CHANGE_A:
 	case SSL3_ST_CR_CHANGE_A:
-		str = "3RCCSA";
+		return "3RCCSA";
-		break;
 	case SSL3_ST_SR_CHANGE_B:
 	case SSL3_ST_CR_CHANGE_B:
-		str = "3RCCSB";
+		return "3RCCSB";
-		break;
 	case SSL3_ST_SR_FINISHED_A:
 	case SSL3_ST_CR_FINISHED_A:
-		str = "3RFINA";
+		return "3RFINA";
-		break;
 	case SSL3_ST_SR_FINISHED_B:
 	case SSL3_ST_CR_FINISHED_B:
-		str = "3RFINB";
+		return "3RFINB";
-		break;
 
 	case SSL3_ST_SW_HELLO_REQ_A:
-		str = "3WHR_A";
+		return "3WHR_A";
-		break;
 	case SSL3_ST_SW_HELLO_REQ_B:
-		str = "3WHR_B";
+		return "3WHR_B";
-		break;
 	case SSL3_ST_SW_HELLO_REQ_C:
-		str = "3WHR_C";
+		return "3WHR_C";
-		break;
 	case SSL3_ST_SR_CLNT_HELLO_A:
-		str = "3RCH_A";
+		return "3RCH_A";
-		break;
 	case SSL3_ST_SR_CLNT_HELLO_B:
-		str = "3RCH_B";
+		return "3RCH_B";
-		break;
 	case SSL3_ST_SR_CLNT_HELLO_C:
-		str = "3RCH_C";
+		return "3RCH_C";
-		break;
 	case SSL3_ST_SW_SRVR_HELLO_A:
-		str = "3WSH_A";
+		return "3WSH_A";
-		break;
 	case SSL3_ST_SW_SRVR_HELLO_B:
-		str = "3WSH_B";
+		return "3WSH_B";
-		break;
 	case SSL3_ST_SW_CERT_A:
-		str = "3WSC_A";
+		return "3WSC_A";
-		break;
 	case SSL3_ST_SW_CERT_B:
-		str = "3WSC_B";
+		return "3WSC_B";
-		break;
 	case SSL3_ST_SW_KEY_EXCH_A:
-		str = "3WSKEA";
+		return "3WSKEA";
-		break;
 	case SSL3_ST_SW_KEY_EXCH_B:
-		str = "3WSKEB";
+		return "3WSKEB";
-		break;
 	case SSL3_ST_SW_CERT_REQ_A:
-		str = "3WCR_A";
+		return "3WCR_A";
-		break;
 	case SSL3_ST_SW_CERT_REQ_B:
-		str = "3WCR_B";
+		return "3WCR_B";
-		break;
 	case SSL3_ST_SW_SRVR_DONE_A:
-		str = "3WSD_A";
+		return "3WSD_A";
-		break;
 	case SSL3_ST_SW_SRVR_DONE_B:
-		str = "3WSD_B";
+		return "3WSD_B";
-		break;
 	case SSL3_ST_SR_CERT_A:
-		str = "3RCC_A";
+		return "3RCC_A";
-		break;
 	case SSL3_ST_SR_CERT_B:
-		str = "3RCC_B";
+		return "3RCC_B";
-		break;
 	case SSL3_ST_SR_KEY_EXCH_A:
-		str = "3RCKEA";
+		return "3RCKEA";
-		break;
 	case SSL3_ST_SR_KEY_EXCH_B:
-		str = "3RCKEB";
+		return "3RCKEB";
-		break;
 	case SSL3_ST_SR_CERT_VRFY_A:
-		str = "3RCV_A";
+		return "3RCV_A";
-		break;
 	case SSL3_ST_SR_CERT_VRFY_B:
-		str = "3RCV_B";
+		return "3RCV_B";
-		break;
 
 	/* DTLS */
 	case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A:
-		str = "DRCHVA";
+		return "DRCHVA";
-		break;
 	case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B:
-		str = "DRCHVB";
+		return "DRCHVB";
-		break;
 	case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:
-		str = "DWCHVA";
+		return "DWCHVA";
-		break;
 	case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:
-		str = "DWCHVB";
+		return "DWCHVB";
-		break;
 
 	default:
-		str = "UNKWN ";
+		return "UNKWN ";
-		break;
 	}
-	return (str);
 }
 LSSL_ALIAS(SSL_state_string);
 
@@ -556,11 +414,11 @@ SSL_alert_type_string_long(int value)
 {
 	value >>= 8;
 	if (value == SSL3_AL_WARNING)
-		return ("warning");
+		return "warning";
 	else if (value == SSL3_AL_FATAL)
-		return ("fatal");
+		return "fatal";
 	else
-		return ("unknown");
+		return "unknown";
 }
 LSSL_ALIAS(SSL_alert_type_string_long);
 
@@ -569,247 +427,170 @@ SSL_alert_type_string(int value)
 {
 	value >>= 8;
 	if (value == SSL3_AL_WARNING)
-		return ("W");
+		return "W";
 	else if (value == SSL3_AL_FATAL)
-		return ("F");
+		return "F";
 	else
-		return ("U");
+		return "U";
 }
 LSSL_ALIAS(SSL_alert_type_string);
 
 const char *
 SSL_alert_desc_string(int value)
 {
-	const char *str;
-
 	switch (value & 0xff) {
 	case SSL_AD_CLOSE_NOTIFY:
-		str = "CN";
+		return "CN";
-		break;
 	case SSL_AD_UNEXPECTED_MESSAGE:
-		str = "UM";
+		return "UM";
-		break;
 	case SSL_AD_BAD_RECORD_MAC:
-		str = "BM";
+		return "BM";
-		break;
 	case SSL_AD_RECORD_OVERFLOW:
-		str = "RO";
+		return "RO";
-		break;
 	case SSL_AD_DECOMPRESSION_FAILURE:
-		str = "DF";
+		return "DF";
-		break;
 	case SSL_AD_HANDSHAKE_FAILURE:
-		str = "HF";
+		return "HF";
-		break;
 	case SSL_AD_BAD_CERTIFICATE:
-		str = "BC";
+		return "BC";
-		break;
 	case SSL_AD_UNSUPPORTED_CERTIFICATE:
-		str = "UC";
+		return "UC";
-		break;
 	case SSL_AD_CERTIFICATE_REVOKED:
-		str = "CR";
+		return "CR";
-		break;
 	case SSL_AD_CERTIFICATE_EXPIRED:
-		str = "CE";
+		return "CE";
-		break;
 	case SSL_AD_CERTIFICATE_UNKNOWN:
-		str = "CU";
+		return "CU";
-		break;
 	case SSL_AD_ILLEGAL_PARAMETER:
-		str = "IP";
+		return "IP";
-		break;
 	case SSL_AD_UNKNOWN_CA:
-		str = "CA";
+		return "CA";
-		break;
 	case SSL_AD_ACCESS_DENIED:
-		str = "AD";
+		return "AD";
-		break;
 	case SSL_AD_DECODE_ERROR:
-		str = "DE";
+		return "DE";
-		break;
 	case SSL_AD_DECRYPT_ERROR:
-		str = "CY";
+		return "CY";
-		break;
 	case SSL_AD_PROTOCOL_VERSION:
-		str = "PV";
+		return "PV";
-		break;
 	case SSL_AD_INSUFFICIENT_SECURITY:
-		str = "IS";
+		return "IS";
-		break;
 	case SSL_AD_INTERNAL_ERROR:
-		str = "IE";
+		return "IE";
-		break;
 	case SSL_AD_INAPPROPRIATE_FALLBACK:
-		str = "IF";
+		return "IF";
-		break;
 	case SSL_AD_USER_CANCELLED:
-		str = "US";
+		return "US";
-		break;
 	case SSL_AD_NO_RENEGOTIATION:
-		str = "NR";
+		return "NR";
-		break;
 	case SSL_AD_MISSING_EXTENSION:
-		str = "ME";
+		return "ME";
-		break;
 	case SSL_AD_UNSUPPORTED_EXTENSION:
-		str = "UE";
+		return "UE";
-		break;
 	case SSL_AD_CERTIFICATE_UNOBTAINABLE:
-		str = "CO";
+		return "CO";
-		break;
 	case SSL_AD_UNRECOGNIZED_NAME:
-		str = "UN";
+		return "UN";
-		break;
 	case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
-		str = "BR";
+		return "BR";
-		break;
 	case SSL_AD_BAD_CERTIFICATE_HASH_VALUE:
-		str = "BH";
+		return "BH";
-		break;
 	case SSL_AD_UNKNOWN_PSK_IDENTITY:
-		str = "UP";
+		return "UP";
-		break;
 	case SSL_AD_CERTIFICATE_REQUIRED:
-		str = "CQ"; /* XXX */
+		return "CQ"; /* XXX */
-		break;
 	case SSL_AD_NO_APPLICATION_PROTOCOL:
-		str = "AP";
+		return "AP";
-		break;
 	default:
-		str = "UK";
+		return "UK";
-		break;
 	}
-	return (str);
 }
 LSSL_ALIAS(SSL_alert_desc_string);
 
 const char *
 SSL_alert_desc_string_long(int value)
 {
-	const char *str;
-
 	switch (value & 0xff) {
 	case SSL_AD_CLOSE_NOTIFY:
-		str = "close notify";
+		return "close notify";
-		break;
 	case SSL_AD_UNEXPECTED_MESSAGE:
-		str = "unexpected_message";
+		return "unexpected_message";
-		break;
 	case SSL_AD_BAD_RECORD_MAC:
-		str = "bad record mac";
+		return "bad record mac";
-		break;
 	case SSL_AD_RECORD_OVERFLOW:
-		str = "record overflow";
+		return "record overflow";
-		break;
 	case SSL_AD_DECOMPRESSION_FAILURE:
-		str = "decompression failure";
+		return "decompression failure";
-		break;
 	case SSL_AD_HANDSHAKE_FAILURE:
-		str = "handshake failure";
+		return "handshake failure";
-		break;
 	case SSL_AD_BAD_CERTIFICATE:
-		str = "bad certificate";
+		return "bad certificate";
-		break;
 	case SSL_AD_UNSUPPORTED_CERTIFICATE:
-		str = "unsupported certificate";
+		return "unsupported certificate";
-		break;
 	case SSL_AD_CERTIFICATE_REVOKED:
-		str = "certificate revoked";
+		return "certificate revoked";
-		break;
 	case SSL_AD_CERTIFICATE_EXPIRED:
-		str = "certificate expired";
+		return "certificate expired";
-		break;
 	case SSL_AD_CERTIFICATE_UNKNOWN:
-		str = "certificate unknown";
+		return "certificate unknown";
-		break;
 	case SSL_AD_ILLEGAL_PARAMETER:
-		str = "illegal parameter";
+		return "illegal parameter";
-		break;
 	case SSL_AD_UNKNOWN_CA:
-		str = "unknown CA";
+		return "unknown CA";
-		break;
 	case SSL_AD_ACCESS_DENIED:
-		str = "access denied";
+		return "access denied";
-		break;
 	case SSL_AD_DECODE_ERROR:
-		str = "decode error";
+		return "decode error";
-		break;
 	case SSL_AD_DECRYPT_ERROR:
-		str = "decrypt error";
+		return "decrypt error";
-		break;
 	case SSL_AD_PROTOCOL_VERSION:
-		str = "protocol version";
+		return "protocol version";
-		break;
 	case SSL_AD_INSUFFICIENT_SECURITY:
-		str = "insufficient security";
+		return "insufficient security";
-		break;
 	case SSL_AD_INTERNAL_ERROR:
-		str = "internal error";
+		return "internal error";
-		break;
 	case SSL_AD_INAPPROPRIATE_FALLBACK:
-		str = "inappropriate fallback";
+		return "inappropriate fallback";
-		break;
 	case SSL_AD_USER_CANCELLED:
-		str = "user canceled";
+		return "user canceled";
-		break;
 	case SSL_AD_NO_RENEGOTIATION:
-		str = "no renegotiation";
+		return "no renegotiation";
-		break;
 	case SSL_AD_MISSING_EXTENSION:
-		str = "missing extension";
+		return "missing extension";
-		break;
 	case SSL_AD_UNSUPPORTED_EXTENSION:
-		str = "unsupported extension";
+		return "unsupported extension";
-		break;
 	case SSL_AD_CERTIFICATE_UNOBTAINABLE:
-		str = "certificate unobtainable";
+		return "certificate unobtainable";
-		break;
 	case SSL_AD_UNRECOGNIZED_NAME:
-		str = "unrecognized name";
+		return "unrecognized name";
-		break;
 	case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
-		str = "bad certificate status response";
+		return "bad certificate status response";
-		break;
 	case SSL_AD_BAD_CERTIFICATE_HASH_VALUE:
-		str = "bad certificate hash value";
+		return "bad certificate hash value";
-		break;
 	case SSL_AD_UNKNOWN_PSK_IDENTITY:
-		str = "unknown PSK identity";
+		return "unknown PSK identity";
-		break;
 	case SSL_AD_CERTIFICATE_REQUIRED:
-		str = "certificate required";
+		return "certificate required";
-		break;
 	case SSL_AD_NO_APPLICATION_PROTOCOL:
-		str = "no application protocol";
+		return "no application protocol";
-		break;
 	default:
-		str = "unknown";
+		return "unknown";
-		break;
 	}
-	return (str);
 }
 LSSL_ALIAS(SSL_alert_desc_string_long);
 
 const char *
 SSL_rstate_string(const SSL *s)
 {
-	const char *str;
-
 	switch (s->rstate) {
 	case SSL_ST_READ_HEADER:
-		str = "RH";
+		return "RH";
-		break;
 	case SSL_ST_READ_BODY:
-		str = "RB";
+		return "RB";
-		break;
 	case SSL_ST_READ_DONE:
-		str = "RD";
+		return "RD";
-		break;
 	default:
-		str = "unknown";
+		return "unknown";
-		break;
 	}
-	return (str);
 }
 LSSL_ALIAS(SSL_rstate_string);

regress/lib/libcrypto/ec/ec_asn1_test.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_asn1_test.c,v 1.2 2021/12/04 17:03:43 tb Exp $ */
+/* $OpenBSD: ec_asn1_test.c,v 1.3 2024/10/12 16:15:28 tb Exp $ */
 /*
  * Copyright (c) 2017, 2021 Joel Sing <jsing@openbsd.org>
  *
@@ -194,6 +194,107 @@ ec_group_pkparameters_parameters_test(void)
 	    sizeof(ec_secp256r1_pkparameters_parameters));
 }
 
+static int
+ec_group_roundtrip_curve(const EC_GROUP *group, const char *descr, int nid)
+{
+	EC_GROUP *new_group = NULL;
+	unsigned char *der = NULL;
+	int der_len;
+	const unsigned char *p;
+	int failed = 1;
+
+	der = NULL;
+	if ((der_len = i2d_ECPKParameters(group, &der)) <= 0)
+		errx(1, "failed to serialize %s %d", descr, nid);
+
+	p = der;
+	if ((new_group = d2i_ECPKParameters(NULL, &p, der_len)) == NULL)
+		errx(1, "failed to deserialize %s %d", descr, nid);
+
+	if (EC_GROUP_cmp(group, new_group, NULL) != 0) {
+		fprintf(stderr, "FAIL: %s %d groups mismatch\n", descr, nid);
+		goto err;
+	}
+	if (EC_GROUP_get_asn1_flag(group) != EC_GROUP_get_asn1_flag(new_group)) {
+		fprintf(stderr, "FAIL: %s %d asn1_flag %x != %x\n", descr, nid,
+		    EC_GROUP_get_asn1_flag(group),
+		    EC_GROUP_get_asn1_flag(new_group));
+		goto err;
+	}
+	if (EC_GROUP_get_point_conversion_form(group) !=
+	    EC_GROUP_get_point_conversion_form(new_group)) {
+		fprintf(stderr, "FAIL: %s %d form %02x != %02x\n", descr, nid,
+		    EC_GROUP_get_point_conversion_form(group),
+		    EC_GROUP_get_point_conversion_form(new_group));
+		goto err;
+	}
+
+	failed = 0;
+
+ err:
+	EC_GROUP_free(new_group);
+	free(der);
+
+	return failed;
+}
+
+static int
+ec_group_roundtrip_builtin_curve(const EC_builtin_curve *curve)
+{
+	EC_GROUP *group = NULL;
+	int failed = 0;
+
+	if ((group = EC_GROUP_new_by_curve_name(curve->nid)) == NULL)
+		errx(1, "failed to instantiate curve %d", curve->nid);
+
+	if (EC_GROUP_get_asn1_flag(group) != OPENSSL_EC_NAMED_CURVE) {
+		fprintf(stderr, "FAIL: ASN.1 flag not set for %d\n", curve->nid);
+		goto err;
+	}
+	if (EC_GROUP_get_point_conversion_form(group) !=
+	    POINT_CONVERSION_UNCOMPRESSED) {
+		fprintf(stderr, "FAIL: %d has point conversion form %02x\n",
+		    curve->nid, EC_GROUP_get_point_conversion_form(group));
+		goto err;
+	}
+
+	failed |= ec_group_roundtrip_curve(group, "named", curve->nid);
+
+	EC_GROUP_set_asn1_flag(group, 0);
+	failed |= ec_group_roundtrip_curve(group, "explicit", curve->nid);
+
+	EC_GROUP_set_point_conversion_form(group, POINT_CONVERSION_COMPRESSED);
+	failed |= ec_group_roundtrip_curve(group, "compressed", curve->nid);
+
+	EC_GROUP_set_point_conversion_form(group, POINT_CONVERSION_HYBRID);
+	failed |= ec_group_roundtrip_curve(group, "hybrid", curve->nid);
+
+ err:
+	EC_GROUP_free(group);
+
+	return failed;
+}
+
+static int
+ec_group_roundtrip_builtin_curves(void)
+{
+	EC_builtin_curve *all_curves = NULL;
+	size_t curve_id, ncurves;
+	int failed = 0;
+
+	ncurves = EC_get_builtin_curves(NULL, 0);
+	if ((all_curves = calloc(ncurves, sizeof(*all_curves))) == NULL)
+		err(1, "calloc builtin curves");
+	EC_get_builtin_curves(all_curves, ncurves);
+
+	for (curve_id = 0; curve_id < ncurves; curve_id++)
+		failed |= ec_group_roundtrip_builtin_curve(&all_curves[curve_id]);
+
+	free(all_curves);
+
+	return failed;
+}
+
 int
 main(int argc, char **argv)
 {
@@ -201,6 +302,7 @@ main(int argc, char **argv)
 
 	failed |= ec_group_pkparameters_named_curve_test();
 	failed |= ec_group_pkparameters_parameters_test();
+	failed |= ec_group_roundtrip_builtin_curves();
 
 	return (failed);
 }

regress/lib/libcrypto/err/err_test.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: err_test.c,v 1.1 2024/10/02 14:41:46 jsing Exp $ */
+/* $OpenBSD: err_test.c,v 1.2 2024/10/11 07:54:22 jsing Exp $ */
 /*
  * Copyright (c) 2024 Joel Sing <jsing@openbsd.org>
  *
@@ -130,6 +130,24 @@ err_test(void)
 
 	ERR_clear_error();
 
+	/*
+	 * Check SYSerror() reasons, which are dynamically populated from
+	 * strerror().
+	 */
+	ERR_put_error(ERR_LIB_SYS, 0xfff, 1, "err.c", 300);
+
+	if ((err = ERR_get_error()) != 0x2fff001UL) {
+		fprintf(stderr, "FAIL: ERR_get_error() = %lx, want "
+		    "0x2fff001UL\n", err);
+		goto failure;
+	}
+	s = ERR_reason_error_string(err);
+	if (strcmp(s, strerror(ERR_GET_REASON(err))) != 0) {
+		fprintf(stderr, "FAIL: ERR_reason_error_string() = '%s', "
+		    "want '%s'\n", s, strerror(ERR_GET_REASON(err)));
+		goto failure;
+	}
+
 	s = ERR_lib_error_string(0x3fff067UL);
 	if (strcmp(s, "bignum routines") != 0) {
 		fprintf(stderr, "FAIL: ERR_lib_error_string() = '%s', "

share/man/man1/dpb-replay.1

@@ -1,4 +1,4 @@
-.\"	$OpenBSD: dpb-replay.1,v 1.4 2023/07/06 10:57:03 espie Exp $
+.\"	$OpenBSD: dpb-replay.1,v 1.5 2024/10/12 15:40:36 jmc Exp $
 .\"
 .\" Copyright (c) 2013 Marc Espie <espie@openbsd.org>
 .\"
@@ -14,7 +14,7 @@
 .\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 .\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 .\"
-.Dd $Mdocdate: July 6 2023 $
+.Dd $Mdocdate: October 12 2024 $
 .Dt DPB-REPLAY 1
 .Os
 .Sh NAME
@@ -55,7 +55,6 @@ Starts display when the time matches timestamp, as either
 seconds from the epoch, or a reasonable subset of ISO8601,
 like
 .Sq 2023-07-05T12:00 .
-
 .El
 .Sh SEE ALSO
 .Xr dpb 1

sys/dev/fdt/qccpu.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: qccpu.c,v 1.3 2024/05/13 01:15:50 jsg Exp $	*/
+/*	$OpenBSD: qccpu.c,v 1.4 2024/10/10 23:15:27 jsg Exp $	*/
 /*
  * Copyright (c) 2023 Dale Rahn <drahn@openbsd.org>
  *
@@ -49,11 +49,6 @@
 #define CPUF_PERF_STATE		0x320
 #define LUT_ROW_SIZE  		4
 
-struct cpu_freq_tbl {
-	uint32_t driver_data;
-	uint32_t frequency;
-};
-
 #define NUM_GROUP	2
 #define MAX_LUT		40
 

sys/dev/pci/drm/amd/amdgpu/amdgpu_amdkfd.c

@@ -340,15 +340,15 @@ allocate_mem_reserve_bo_failed:
 	return r;
 }
 
-void amdgpu_amdkfd_free_gtt_mem(struct amdgpu_device *adev, void *mem_obj)
+void amdgpu_amdkfd_free_gtt_mem(struct amdgpu_device *adev, void **mem_obj)
 {
-	struct amdgpu_bo *bo = (struct amdgpu_bo *) mem_obj;
+	struct amdgpu_bo **bo = (struct amdgpu_bo **) mem_obj;
 
-	amdgpu_bo_reserve(bo, true);
+	amdgpu_bo_reserve(*bo, true);
-	amdgpu_bo_kunmap(bo);
+	amdgpu_bo_kunmap(*bo);
-	amdgpu_bo_unpin(bo);
+	amdgpu_bo_unpin(*bo);
-	amdgpu_bo_unreserve(bo);
+	amdgpu_bo_unreserve(*bo);
-	amdgpu_bo_unref(&(bo));
+	amdgpu_bo_unref(bo);
 }
 
 int amdgpu_amdkfd_alloc_gws(struct amdgpu_device *adev, size_t size,

sys/dev/pci/drm/amd/amdgpu/amdgpu_amdkfd.h

@@ -221,7 +221,7 @@ int amdgpu_amdkfd_evict_userptr(struct mmu_interval_notifier *mni,
 int amdgpu_amdkfd_alloc_gtt_mem(struct amdgpu_device *adev, size_t size,
 				void **mem_obj, uint64_t *gpu_addr,
 				void **cpu_ptr, bool mqd_gfx9);
-void amdgpu_amdkfd_free_gtt_mem(struct amdgpu_device *adev, void *mem_obj);
+void amdgpu_amdkfd_free_gtt_mem(struct amdgpu_device *adev, void **mem_obj);
 int amdgpu_amdkfd_alloc_gws(struct amdgpu_device *adev, size_t size,
 				void **mem_obj);
 void amdgpu_amdkfd_free_gws(struct amdgpu_device *adev, void *mem_obj);

sys/dev/pci/drm/amd/amdgpu/amdgpu_cs.c

@@ -263,6 +263,10 @@ static int amdgpu_cs_pass1(struct amdgpu_cs_parser *p,
 			if (size < sizeof(struct drm_amdgpu_bo_list_in))
 				goto free_partial_kdata;
 
+			/* Only a single BO list is allowed to simplify handling. */
+			if (p->bo_list)
+				ret = -EINVAL;
+
 			ret = amdgpu_cs_p1_bo_handles(p, p->chunks[i].kdata);
 			if (ret)
 				goto free_partial_kdata;

sys/dev/pci/drm/amd/amdgpu/amdgpu_gfx.c

@@ -795,8 +795,11 @@ int amdgpu_gfx_ras_late_init(struct amdgpu_device *adev, struct ras_common_if *r
 	int r;
 
 	if (amdgpu_ras_is_supported(adev, ras_block->block)) {
-		if (!amdgpu_persistent_edc_harvesting_supported(adev))
+		if (!amdgpu_persistent_edc_harvesting_supported(adev)) {
-			amdgpu_ras_reset_error_status(adev, AMDGPU_RAS_BLOCK__GFX);
+			r = amdgpu_ras_reset_error_status(adev, AMDGPU_RAS_BLOCK__GFX);
+			if (r)
+				return r;
+		}
 
 		r = amdgpu_ras_block_late_init(adev, ras_block);
 		if (r)
@@ -941,7 +944,10 @@ uint32_t amdgpu_kiq_rreg(struct amdgpu_device *adev, uint32_t reg)
 		pr_err("critical bug! too many kiq readers\n");
 		goto failed_unlock;
 	}
-	amdgpu_ring_alloc(ring, 32);
+	r = amdgpu_ring_alloc(ring, 32);
+	if (r)
+		goto failed_unlock;
+
 	amdgpu_ring_emit_rreg(ring, reg, reg_val_offs);
 	r = amdgpu_fence_emit_polling(ring, &seq, MAX_KIQ_REG_WAIT);
 	if (r)
@@ -1007,7 +1013,10 @@ void amdgpu_kiq_wreg(struct amdgpu_device *adev, uint32_t reg, uint32_t v)
 	}
 
 	spin_lock_irqsave(&kiq->ring_lock, flags);
-	amdgpu_ring_alloc(ring, 32);
+	r = amdgpu_ring_alloc(ring, 32);
+	if (r)
+		goto failed_unlock;
+
 	amdgpu_ring_emit_wreg(ring, reg, v);
 	r = amdgpu_fence_emit_polling(ring, &seq, MAX_KIQ_REG_WAIT);
 	if (r)
@@ -1043,6 +1052,7 @@ void amdgpu_kiq_wreg(struct amdgpu_device *adev, uint32_t reg, uint32_t v)
 
 failed_undo:
 	amdgpu_ring_undo(ring);
+failed_unlock:
 	spin_unlock_irqrestore(&kiq->ring_lock, flags);
 failed_kiq_write:
 	dev_err(adev->dev, "failed to write reg:%x\n", reg);

sys/dev/pci/drm/amd/amdgpu/amdgpu_kms.c

@@ -43,6 +43,7 @@
 #include "amdgpu_gem.h"
 #include "amdgpu_display.h"
 #include "amdgpu_ras.h"
+#include "amdgpu_reset.h"
 #include "amd_pcie.h"
 
 void amdgpu_unregister_gpu_instance(struct amdgpu_device *adev)
@@ -722,6 +723,7 @@ int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 				    ? -EFAULT : 0;
 	}
 	case AMDGPU_INFO_READ_MMR_REG: {
+		int ret = 0;
 		unsigned int n, alloc_size;
 		uint32_t *regs;
 		unsigned int se_num = (info->read_mmr_reg.instance >>
@@ -731,24 +733,37 @@ int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 				   AMDGPU_INFO_MMR_SH_INDEX_SHIFT) &
 				  AMDGPU_INFO_MMR_SH_INDEX_MASK;
 
+		if (!down_read_trylock(&adev->reset_domain->sem))
+			return -ENOENT;
+
 		/* set full masks if the userspace set all bits
 		 * in the bitfields
 		 */
-		if (se_num == AMDGPU_INFO_MMR_SE_INDEX_MASK)
+		if (se_num == AMDGPU_INFO_MMR_SE_INDEX_MASK) {
 			se_num = 0xffffffff;
-		else if (se_num >= AMDGPU_GFX_MAX_SE)
+		} else if (se_num >= AMDGPU_GFX_MAX_SE) {
-			return -EINVAL;
+			ret = -EINVAL;
-		if (sh_num == AMDGPU_INFO_MMR_SH_INDEX_MASK)
+			goto out;
-			sh_num = 0xffffffff;
+		}
-		else if (sh_num >= AMDGPU_GFX_MAX_SH_PER_SE)
-			return -EINVAL;
 
-		if (info->read_mmr_reg.count > 128)
+		if (sh_num == AMDGPU_INFO_MMR_SH_INDEX_MASK) {
-			return -EINVAL;
+			sh_num = 0xffffffff;
+		} else if (sh_num >= AMDGPU_GFX_MAX_SH_PER_SE) {
+			ret = -EINVAL;
+			goto out;
+		}
+
+		if (info->read_mmr_reg.count > 128) {
+			ret = -EINVAL;
+			goto out;
+		}
 
 		regs = kmalloc_array(info->read_mmr_reg.count, sizeof(*regs), GFP_KERNEL);
-		if (!regs)
+		if (!regs) {
-			return -ENOMEM;
+			ret = -ENOMEM;
+			goto out;
+		}
+
 		alloc_size = info->read_mmr_reg.count * sizeof(*regs);
 
 		amdgpu_gfx_off_ctrl(adev, false);
@@ -760,13 +775,17 @@ int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 					      info->read_mmr_reg.dword_offset + i);
 				kfree(regs);
 				amdgpu_gfx_off_ctrl(adev, true);
-				return -EFAULT;
+				ret = -EFAULT;
+				goto out;
 			}
 		}
 		amdgpu_gfx_off_ctrl(adev, true);
 		n = copy_to_user(out, regs, min(size, alloc_size));
 		kfree(regs);
-		return n ? -EFAULT : 0;
+		ret = (n ? -EFAULT : 0);
+out:
+		up_read(&adev->reset_domain->sem);
+		return ret;
 	}
 	case AMDGPU_INFO_DEV_INFO: {
 		struct drm_amdgpu_info_device *dev_info;

sys/dev/pci/drm/amd/amdgpu/amdgpu_xcp.h

@@ -179,6 +179,6 @@ amdgpu_get_next_xcp(struct amdgpu_xcp_mgr *xcp_mgr, int *from)
 
 #define for_each_xcp(xcp_mgr, xcp, i)                            \
 	for (i = 0, xcp = amdgpu_get_next_xcp(xcp_mgr, &i); xcp; \
-	     xcp = amdgpu_get_next_xcp(xcp_mgr, &i))
+	     ++i, xcp = amdgpu_get_next_xcp(xcp_mgr, &i))
 
 #endif

sys/dev/pci/drm/amd/amdgpu/gfx_v10_0.c

@@ -8748,7 +8748,9 @@ static void gfx_v10_0_ring_soft_recovery(struct amdgpu_ring *ring,
 	value = REG_SET_FIELD(value, SQ_CMD, MODE, 0x01);
 	value = REG_SET_FIELD(value, SQ_CMD, CHECK_VMID, 1);
 	value = REG_SET_FIELD(value, SQ_CMD, VM_ID, vmid);
+	amdgpu_gfx_rlc_enter_safe_mode(adev, 0);
 	WREG32_SOC15(GC, 0, mmSQ_CMD, value);
+	amdgpu_gfx_rlc_exit_safe_mode(adev, 0);
 }
 
 static void

sys/dev/pci/drm/amd/amdgpu/gfx_v11_0.c

@@ -5701,7 +5701,9 @@ static void gfx_v11_0_ring_soft_recovery(struct amdgpu_ring *ring,
 	value = REG_SET_FIELD(value, SQ_CMD, MODE, 0x01);
 	value = REG_SET_FIELD(value, SQ_CMD, CHECK_VMID, 1);
 	value = REG_SET_FIELD(value, SQ_CMD, VM_ID, vmid);
+	amdgpu_gfx_rlc_enter_safe_mode(adev, 0);
 	WREG32_SOC15(GC, 0, regSQ_CMD, value);
+	amdgpu_gfx_rlc_exit_safe_mode(adev, 0);
 }
 
 static void

sys/dev/pci/drm/amd/amdgpu/gfx_v9_0.c

@@ -1172,6 +1172,10 @@ static const struct amdgpu_gfxoff_quirk amdgpu_gfxoff_quirk_list[] = {
 	{ 0x1002, 0x15dd, 0x1002, 0x15dd, 0xc6 },
 	/* Apple MacBook Pro (15-inch, 2019) Radeon Pro Vega 20 4 GB */
 	{ 0x1002, 0x69af, 0x106b, 0x019a, 0xc0 },
+	/* https://bbs.openkylin.top/t/topic/171497 */
+	{ 0x1002, 0x15d8, 0x19e5, 0x3e14, 0xc2 },
+	/* HP 705G4 DM with R5 2400G */
+	{ 0x1002, 0x15dd, 0x103c, 0x8464, 0xd6 },
 	{ 0, 0, 0, 0, 0 },
 };
 
@@ -5705,7 +5709,9 @@ static void gfx_v9_0_ring_soft_recovery(struct amdgpu_ring *ring, unsigned vmid)
 	value = REG_SET_FIELD(value, SQ_CMD, MODE, 0x01);
 	value = REG_SET_FIELD(value, SQ_CMD, CHECK_VMID, 1);
 	value = REG_SET_FIELD(value, SQ_CMD, VM_ID, vmid);
+	amdgpu_gfx_rlc_enter_safe_mode(adev, 0);
 	WREG32_SOC15(GC, 0, mmSQ_CMD, value);
+	amdgpu_gfx_rlc_exit_safe_mode(adev, 0);
 }
 
 static void gfx_v9_0_set_gfx_eop_interrupt_state(struct amdgpu_device *adev,

sys/dev/pci/drm/amd/amdkfd/kfd_chardev.c

@@ -417,7 +417,7 @@ static int kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,
 
 err_create_queue:
 	if (wptr_bo)
-		amdgpu_amdkfd_free_gtt_mem(dev->adev, wptr_bo);
+		amdgpu_amdkfd_free_gtt_mem(dev->adev, (void **)&wptr_bo);
 err_wptr_map_gart:
 err_bind_process:
 err_pdd:

sys/dev/pci/drm/amd/amdkfd/kfd_device.c

@@ -838,7 +838,7 @@ node_alloc_error:
 kfd_doorbell_error:
 	kfd_gtt_sa_fini(kfd);
 kfd_gtt_sa_init_error:
-	amdgpu_amdkfd_free_gtt_mem(kfd->adev, kfd->gtt_mem);
+	amdgpu_amdkfd_free_gtt_mem(kfd->adev, &kfd->gtt_mem);
 alloc_gtt_mem_failure:
 	dev_err(kfd_device,
 		"device %x:%x NOT added due to errors\n",
@@ -856,7 +856,7 @@ void kgd2kfd_device_exit(struct kfd_dev *kfd)
 		kfd_doorbell_fini(kfd);
 		ida_destroy(&kfd->doorbell_ida);
 		kfd_gtt_sa_fini(kfd);
-		amdgpu_amdkfd_free_gtt_mem(kfd->adev, kfd->gtt_mem);
+		amdgpu_amdkfd_free_gtt_mem(kfd->adev, &kfd->gtt_mem);
 	}
 
 	kfree(kfd);

sys/dev/pci/drm/amd/amdkfd/kfd_device_queue_manager.c

@@ -2610,7 +2610,7 @@ static void deallocate_hiq_sdma_mqd(struct kfd_node *dev,
 {
 	WARN(!mqd, "No hiq sdma mqd trunk to free");
 
-	amdgpu_amdkfd_free_gtt_mem(dev->adev, mqd->gtt_mem);
+	amdgpu_amdkfd_free_gtt_mem(dev->adev, &mqd->gtt_mem);
 }
 
 void device_queue_manager_uninit(struct device_queue_manager *dqm)

sys/dev/pci/drm/amd/amdkfd/kfd_mqd_manager.c

@@ -223,7 +223,7 @@ void kfd_free_mqd_cp(struct mqd_manager *mm, void *mqd,
 	      struct kfd_mem_obj *mqd_mem_obj)
 {
 	if (mqd_mem_obj->gtt_mem) {
-		amdgpu_amdkfd_free_gtt_mem(mm->dev->adev, mqd_mem_obj->gtt_mem);
+		amdgpu_amdkfd_free_gtt_mem(mm->dev->adev, &mqd_mem_obj->gtt_mem);
 		kfree(mqd_mem_obj);
 	} else {
 		kfd_gtt_sa_free(mm->dev, mqd_mem_obj);

sys/dev/pci/drm/amd/amdkfd/kfd_process.c

@@ -1047,7 +1047,7 @@ static void kfd_process_destroy_pdds(struct kfd_process *p)
 
 		if (pdd->dev->kfd->shared_resources.enable_mes)
 			amdgpu_amdkfd_free_gtt_mem(pdd->dev->adev,
-						   pdd->proc_ctx_bo);
+						   &pdd->proc_ctx_bo);
 		/*
 		 * before destroying pdd, make sure to report availability
 		 * for auto suspend

sys/dev/pci/drm/amd/amdkfd/kfd_process_queue_manager.c

@@ -199,9 +199,9 @@ static void pqm_clean_queue_resource(struct process_queue_manager *pqm,
 	}
 
 	if (dev->kfd->shared_resources.enable_mes) {
-		amdgpu_amdkfd_free_gtt_mem(dev->adev, pqn->q->gang_ctx_bo);
+		amdgpu_amdkfd_free_gtt_mem(dev->adev, &pqn->q->gang_ctx_bo);
 		if (pqn->q->wptr_bo)
-			amdgpu_amdkfd_free_gtt_mem(dev->adev, pqn->q->wptr_bo);
+			amdgpu_amdkfd_free_gtt_mem(dev->adev, (void **)&pqn->q->wptr_bo);
 	}
 }
 
@@ -982,6 +982,7 @@ exit:
 		pr_debug("Queue id %d was restored successfully\n", queue_id);
 
 	kfree(q_data);
+	kfree(q_extra_data);
 
 	return ret;
 }

sys/dev/pci/drm/amd/display/amdgpu_dm/amdgpu_dm.c

@@ -714,6 +714,12 @@ static void dmub_hpd_callback(struct amdgpu_device *adev,
 		return;
 	}
 
+	/* Skip DMUB HPD IRQ in suspend/resume. We will probe them later. */
+	if (notify->type == DMUB_NOTIFICATION_HPD && adev->in_suspend) {
+		DRM_INFO("Skip DMUB HPD IRQ callback in suspend/resume\n");
+		return;
+	}
+
 	link_index = notify->link_index;
 	link = adev->dm.dc->links[link_index];
 	dev = adev->dm.ddev;
@@ -4062,7 +4068,7 @@ static void amdgpu_dm_update_backlight_caps(struct amdgpu_display_manager *dm,
 		int spread = caps.max_input_signal - caps.min_input_signal;
 
 		if (caps.max_input_signal > AMDGPU_DM_DEFAULT_MAX_BACKLIGHT ||
-		    caps.min_input_signal < AMDGPU_DM_DEFAULT_MIN_BACKLIGHT ||
+		    caps.min_input_signal < 0 ||
 		    spread > AMDGPU_DM_DEFAULT_MAX_BACKLIGHT ||
 		    spread < AMDGPU_DM_MIN_SPREAD) {
 			DRM_DEBUG_KMS("DM: Invalid backlight caps: min=%d, max=%d\n",
@@ -6157,12 +6163,21 @@ create_stream_for_sink(struct amdgpu_dm_connector *aconnector,
 	if (stream->signal == SIGNAL_TYPE_DISPLAY_PORT ||
 	    stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST ||
 	    stream->signal == SIGNAL_TYPE_EDP) {
+		const struct dc_edid_caps *edid_caps;
+		unsigned int disable_colorimetry = 0;
+
+		if (aconnector->dc_sink) {
+			edid_caps = &aconnector->dc_sink->edid_caps;
+			disable_colorimetry = edid_caps->panel_patch.disable_colorimetry;
+		}
+
 		//
 		// should decide stream support vsc sdp colorimetry capability
 		// before building vsc info packet
 		//
 		stream->use_vsc_sdp_for_colorimetry = stream->link->dpcd_caps.dpcd_rev.raw >= 0x14 &&
-						      stream->link->dpcd_caps.dprx_feature.bits.VSC_SDP_COLORIMETRY_SUPPORTED;
+						      stream->link->dpcd_caps.dprx_feature.bits.VSC_SDP_COLORIMETRY_SUPPORTED &&
+						      !disable_colorimetry;
 
 		if (stream->out_transfer_func->tf == TRANSFER_FUNCTION_GAMMA22)
 			tf = TRANSFER_FUNC_GAMMA_22;

sys/dev/pci/drm/amd/display/amdgpu_dm/amdgpu_dm_helpers.c

@@ -71,6 +71,10 @@ static void apply_edid_quirks(struct edid *edid, struct dc_edid_caps *edid_caps)
 		DRM_DEBUG_DRIVER("Clearing DPCD 0x317 on monitor with panel id %X\n", panel_id);
 		edid_caps->panel_patch.remove_sink_ext_caps = true;
 		break;
+	case drm_edid_encode_panel_id('S', 'D', 'C', 0x4154):
+		DRM_DEBUG_DRIVER("Disabling VSC on monitor with panel id %X\n", panel_id);
+		edid_caps->panel_patch.disable_colorimetry = true;
+		break;
 	default:
 		return;
 	}

sys/dev/pci/drm/amd/display/amdgpu_dm/amdgpu_dm_plane.c

@@ -1281,7 +1281,8 @@ void amdgpu_dm_plane_handle_cursor_update(struct drm_plane *plane,
 	    adev->dm.dc->caps.color.dpp.gamma_corr)
 		attributes.attribute_flags.bits.ENABLE_CURSOR_DEGAMMA = 1;
 
-	attributes.pitch = afb->base.pitches[0] / afb->base.format->cpp[0];
+	if (afb)
+		attributes.pitch = afb->base.pitches[0] / afb->base.format->cpp[0];
 
 	if (crtc_state->stream) {
 		mutex_lock(&adev->dm.dc_lock);

sys/dev/pci/drm/amd/display/dc/core/amdgpu_dc.c

@@ -3797,7 +3797,8 @@ static void commit_planes_for_stream(struct dc *dc,
 	}
 
 	if ((update_type != UPDATE_TYPE_FAST) && stream->update_flags.bits.dsc_changed)
-		if (top_pipe_to_program->stream_res.tg->funcs->lock_doublebuffer_enable) {
+		if (top_pipe_to_program &&
+		    top_pipe_to_program->stream_res.tg->funcs->lock_doublebuffer_enable) {
 			top_pipe_to_program->stream_res.tg->funcs->wait_for_state(
 				top_pipe_to_program->stream_res.tg,
 				CRTC_STATE_VACTIVE);
@@ -4715,7 +4716,8 @@ void dc_allow_idle_optimizations(struct dc *dc, bool allow)
 	if (allow == dc->idle_optimizations_allowed)
 		return;
 
-	if (dc->hwss.apply_idle_power_optimizations && dc->hwss.apply_idle_power_optimizations(dc, allow))
+	if (dc->hwss.apply_idle_power_optimizations && dc->clk_mgr != NULL &&
+	    dc->hwss.apply_idle_power_optimizations(dc, allow))
 		dc->idle_optimizations_allowed = allow;
 }
 

sys/dev/pci/drm/amd/display/dc/core/dc_resource.c

@@ -2154,6 +2154,8 @@ static bool are_stream_backends_same(
 bool dc_is_stream_unchanged(
 	struct dc_stream_state *old_stream, struct dc_stream_state *stream)
 {
+	if (!old_stream || !stream)
+		return false;
 
 	if (!are_stream_backends_same(old_stream, stream))
 		return false;
@@ -2877,8 +2879,10 @@ static bool planes_changed_for_existing_stream(struct dc_state *context,
 		}
 	}
 
-	if (!stream_status)
+	if (!stream_status) {
 		ASSERT(0);
+		return false;
+	}
 
 	for (i = 0; i < set_count; i++)
 		if (set[i].stream == stream)

sys/dev/pci/drm/amd/display/dc/dc_types.h

@@ -190,6 +190,7 @@ struct dc_panel_patch {
 	unsigned int skip_avmute;
 	unsigned int mst_start_top_delay;
 	unsigned int remove_sink_ext_caps;
+	unsigned int disable_colorimetry;
 };
 
 struct dc_edid_caps {

sys/dev/pci/drm/amd/display/dc/dcn10/dcn10_cm_common.c

@@ -571,6 +571,8 @@ bool cm_helper_translate_curve_to_degamma_hw_format(
 				i += increment) {
 			if (j == hw_points - 1)
 				break;
+			if (i >= TRANSFER_FUNC_POINTS)
+				return false;
 			rgb_resulted[j].red = output_tf->tf_pts.red[i];
 			rgb_resulted[j].green = output_tf->tf_pts.green[i];
 			rgb_resulted[j].blue = output_tf->tf_pts.blue[i];

sys/dev/pci/drm/amd/display/dc/dcn30/dcn30_cm_common.c

@@ -178,6 +178,8 @@ bool cm3_helper_translate_curve_to_hw_format(
 				i += increment) {
 			if (j == hw_points - 1)
 				break;
+			if (i >= TRANSFER_FUNC_POINTS)
+				return false;
 			rgb_resulted[j].red = output_tf->tf_pts.red[i];
 			rgb_resulted[j].green = output_tf->tf_pts.green[i];
 			rgb_resulted[j].blue = output_tf->tf_pts.blue[i];
@@ -355,6 +357,8 @@ bool cm3_helper_translate_curve_to_degamma_hw_format(
 				i += increment) {
 			if (j == hw_points - 1)
 				break;
+			if (i >= TRANSFER_FUNC_POINTS)
+				return false;
 			rgb_resulted[j].red = output_tf->tf_pts.red[i];
 			rgb_resulted[j].green = output_tf->tf_pts.green[i];
 			rgb_resulted[j].blue = output_tf->tf_pts.blue[i];

sys/dev/pci/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

@@ -78,7 +78,7 @@ static void calculate_ttu_cursor(struct display_mode_lib *mode_lib,
 
 static unsigned int get_bytes_per_element(enum source_format_class source_format, bool is_chroma)
 {
-	unsigned int ret_val = 0;
+	unsigned int ret_val = 1;
 
 	if (source_format == dm_444_16) {
 		if (!is_chroma)

sys/dev/pci/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

@@ -53,7 +53,7 @@ static void calculate_ttu_cursor(
 
 static unsigned int get_bytes_per_element(enum source_format_class source_format, bool is_chroma)
 {
-	unsigned int ret_val = 0;
+	unsigned int ret_val = 1;
 
 	if (source_format == dm_444_16) {
 		if (!is_chroma)

sys/dev/pci/drm/amd/display/dc/link/hwss/link_hwss_hpo_dp.c

@@ -28,6 +28,8 @@
 #include "dccg.h"
 #include "clk_mgr.h"
 
+#define DC_LOGGER link->ctx->logger
+
 void set_hpo_dp_throttled_vcp_size(struct pipe_ctx *pipe_ctx,
 		struct fixed31_32 throttled_vcp_size)
 {
@@ -108,6 +110,11 @@ void enable_hpo_dp_link_output(struct dc_link *link,
 		enum clock_source_id clock_source,
 		const struct dc_link_settings *link_settings)
 {
+	if (!link_res->hpo_dp_link_enc) {
+		DC_LOG_ERROR("%s: invalid hpo_dp_link_enc\n", __func__);
+		return;
+	}
+
 	if (link->dc->res_pool->dccg->funcs->set_symclk32_le_root_clock_gating)
 		link->dc->res_pool->dccg->funcs->set_symclk32_le_root_clock_gating(
 				link->dc->res_pool->dccg,
@@ -124,6 +131,11 @@ void disable_hpo_dp_link_output(struct dc_link *link,
 		const struct link_resource *link_res,
 		enum amd_signal_type signal)
 {
+	if (!link_res->hpo_dp_link_enc) {
+		DC_LOG_ERROR("%s: invalid hpo_dp_link_enc\n", __func__);
+		return;
+	}
+
 		link_res->hpo_dp_link_enc->funcs->link_disable(link_res->hpo_dp_link_enc);
 		link_res->hpo_dp_link_enc->funcs->disable_link_phy(
 				link_res->hpo_dp_link_enc, signal);

sys/dev/pci/drm/amd/display/dc/link/link_factory.c

@@ -403,7 +403,7 @@ static void link_destruct(struct dc_link *link)
 	if (link->panel_cntl)
 		link->panel_cntl->funcs->destroy(&link->panel_cntl);
 
-	if (link->link_enc) {
+	if (link->link_enc && !link->is_dig_mapping_flexible) {
 		/* Update link encoder resource tracking variables. These are used for
 		 * the dynamic assignment of link encoders to streams. Virtual links
 		 * are not assigned encoder resources on creation.

sys/dev/pci/drm/amd/pm/powerplay/hwmgr/processpptables.c

@@ -1185,6 +1185,8 @@ static int init_overdrive_limits(struct pp_hwmgr *hwmgr,
 	fw_info = smu_atom_get_data_table(hwmgr->adev,
 			 GetIndexIntoMasterTable(DATA, FirmwareInfo),
 			 &size, &frev, &crev);
+	PP_ASSERT_WITH_CODE(fw_info != NULL,
+			    "Missing firmware info!", return -EINVAL);
 
 	if ((fw_info->ucTableFormatRevision == 1)
 	    && (le16_to_cpu(fw_info->usStructureSize) >= sizeof(ATOM_FIRMWARE_INFO_V1_4)))

sys/dev/pci/drm/drm_atomic_uapi.c

@@ -586,7 +586,7 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
 					&state->fb_damage_clips,
 					val,
 					-1,
-					sizeof(struct drm_rect),
+					sizeof(struct drm_mode_rect),
 					&replaced);
 		return ret;
 	} else if (property == plane->scaling_filter_property) {

sys/dev/pci/drm/drm_print.c

@@ -104,8 +104,9 @@ void __drm_puts_coredump(struct drm_printer *p, const char *str)
 			copy = iterator->remain;
 
 		/* Copy out the bit of the string that we need */
-		memcpy(iterator->data,
+		if (iterator->data)
-			str + (iterator->start - iterator->offset), copy);
+			memcpy(iterator->data,
+			       str + (iterator->start - iterator->offset), copy);
 
 		iterator->offset = iterator->start + copy;
 		iterator->remain -= copy;
@@ -114,7 +115,8 @@ void __drm_puts_coredump(struct drm_printer *p, const char *str)
 
 		len = min_t(ssize_t, strlen(str), iterator->remain);
 
-		memcpy(iterator->data + pos, str, len);
+		if (iterator->data)
+			memcpy(iterator->data + pos, str, len);
 
 		iterator->offset += len;
 		iterator->remain -= len;
@@ -144,8 +146,9 @@ void __drm_printfn_coredump(struct drm_printer *p, struct va_format *vaf)
 	if ((iterator->offset >= iterator->start) && (len < iterator->remain)) {
 		ssize_t pos = iterator->offset - iterator->start;
 
-		snprintf(((char *) iterator->data) + pos,
+		if (iterator->data)
-			iterator->remain, "%pV", vaf);
+			snprintf(((char *) iterator->data) + pos,
+				 iterator->remain, "%pV", vaf);
 
 		iterator->offset += len;
 		iterator->remain -= len;

sys/dev/pci/drm/i915/gem/i915_gem_ttm.c

@@ -1167,7 +1167,7 @@ static vm_fault_t vm_fault_ttm(struct vm_fault *vmf)
 		GEM_WARN_ON(!i915_ttm_cpu_maps_iomem(bo->resource));
 	}
 
-	if (wakeref & CONFIG_DRM_I915_USERFAULT_AUTOSUSPEND)
+	if (wakeref && CONFIG_DRM_I915_USERFAULT_AUTOSUSPEND != 0)
 		intel_wakeref_auto(&to_i915(obj->base.dev)->runtime_pm.userfault_wakeref,
 				   msecs_to_jiffies_timeout(CONFIG_DRM_I915_USERFAULT_AUTOSUSPEND));
 

sys/dev/pci/drm/radeon/r100.c

@@ -1015,45 +1015,65 @@ static int r100_cp_init_microcode(struct radeon_device *rdev)
 
 	DRM_DEBUG_KMS("\n");
 
-	if ((rdev->family == CHIP_R100) || (rdev->family == CHIP_RV100) ||
+	switch (rdev->family) {
-	    (rdev->family == CHIP_RV200) || (rdev->family == CHIP_RS100) ||
+	case CHIP_R100:
-	    (rdev->family == CHIP_RS200)) {
+	case CHIP_RV100:
+	case CHIP_RV200:
+	case CHIP_RS100:
+	case CHIP_RS200:
 		DRM_INFO("Loading R100 Microcode\n");
 		fw_name = FIRMWARE_R100;
-	} else if ((rdev->family == CHIP_R200) ||
+		break;
-		   (rdev->family == CHIP_RV250) ||
+
-		   (rdev->family == CHIP_RV280) ||
+	case CHIP_R200:
-		   (rdev->family == CHIP_RS300)) {
+	case CHIP_RV250:
+	case CHIP_RV280:
+	case CHIP_RS300:
 		DRM_INFO("Loading R200 Microcode\n");
 		fw_name = FIRMWARE_R200;
-	} else if ((rdev->family == CHIP_R300) ||
+		break;
-		   (rdev->family == CHIP_R350) ||
+
-		   (rdev->family == CHIP_RV350) ||
+	case CHIP_R300:
-		   (rdev->family == CHIP_RV380) ||
+	case CHIP_R350:
-		   (rdev->family == CHIP_RS400) ||
+	case CHIP_RV350:
-		   (rdev->family == CHIP_RS480)) {
+	case CHIP_RV380:
+	case CHIP_RS400:
+	case CHIP_RS480:
 		DRM_INFO("Loading R300 Microcode\n");
 		fw_name = FIRMWARE_R300;
-	} else if ((rdev->family == CHIP_R420) ||
+		break;
-		   (rdev->family == CHIP_R423) ||
+
-		   (rdev->family == CHIP_RV410)) {
+	case CHIP_R420:
+	case CHIP_R423:
+	case CHIP_RV410:
 		DRM_INFO("Loading R400 Microcode\n");
 		fw_name = FIRMWARE_R420;
-	} else if ((rdev->family == CHIP_RS690) ||
+		break;
-		   (rdev->family == CHIP_RS740)) {
+
+	case CHIP_RS690:
+	case CHIP_RS740:
 		DRM_INFO("Loading RS690/RS740 Microcode\n");
 		fw_name = FIRMWARE_RS690;
-	} else if (rdev->family == CHIP_RS600) {
+		break;
+
+	case CHIP_RS600:
 		DRM_INFO("Loading RS600 Microcode\n");
 		fw_name = FIRMWARE_RS600;
-	} else if ((rdev->family == CHIP_RV515) ||
+		break;
-		   (rdev->family == CHIP_R520) ||
+
-		   (rdev->family == CHIP_RV530) ||
+	case CHIP_RV515:
-		   (rdev->family == CHIP_R580) ||
+	case CHIP_R520:
-		   (rdev->family == CHIP_RV560) ||
+	case CHIP_RV530:
-		   (rdev->family == CHIP_RV570)) {
+	case CHIP_R580:
+	case CHIP_RV560:
+	case CHIP_RV570:
 		DRM_INFO("Loading R500 Microcode\n");
 		fw_name = FIRMWARE_R520;
+		break;
+
+	default:
+		DRM_ERROR("Unsupported Radeon family %u\n", rdev->family);
+		return -EINVAL;
 	}
 
 	err = request_firmware(&rdev->me_fw, fw_name, rdev->dev);

sys/dev/pci/drm/scheduler/sched_entity.c

@@ -111,8 +111,10 @@ void drm_sched_entity_modify_sched(struct drm_sched_entity *entity,
 {
 	WARN_ON(!num_sched_list || !sched_list);
 
+	spin_lock(&entity->rq_lock);
 	entity->sched_list = sched_list;
 	entity->num_sched_list = num_sched_list;
+	spin_unlock(&entity->rq_lock);
 }
 EXPORT_SYMBOL(drm_sched_entity_modify_sched);
 

sys/dev/usb/ehci.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: ehci.c,v 1.221 2024/10/08 19:42:31 kettenis Exp $ */
+/*	$OpenBSD: ehci.c,v 1.222 2024/10/11 09:55:24 kettenis Exp $ */
 /*	$NetBSD: ehci.c,v 1.66 2004/06/30 03:11:56 mycroft Exp $	*/
 
 /*
@@ -317,7 +317,6 @@ ehci_init(struct ehci_softc *sc)
 	sc->sc_noport = EHCI_HCS_N_PORTS(sparams);
 	cparams = EREAD4(sc, EHCI_HCCPARAMS);
 	DPRINTF(("ehci_init: cparams=0x%x\n", cparams));
-	sc->sc_bus.dmaflags = EHCI_HCC_64BIT(cparams) ? BUS_DMA_64BIT : 0;
 
 	/* MUST clear segment register if 64 bit capable. */
 	if (EHCI_HCC_64BIT(cparams))

sys/sys/hibernate.h

@@ -1,4 +1,4 @@
-/*	$OpenBSD: hibernate.h,v 1.46 2024/06/04 20:31:35 krw Exp $	*/
+/*	$OpenBSD: hibernate.h,v 1.47 2024/10/12 07:30:20 jsg Exp $	*/
 
 /*
  * Copyright (c) 2011 Ariane van der Steldt <ariane@stack.nl>
@@ -22,7 +22,6 @@
 #include <sys/types.h>
 #include <sys/tree.h>
 #include <lib/libz/zlib.h>
-#include <machine/vmparam.h>
 #include <crypto/sha2.h>
 
 #define HIB_PHYSSEG_MAX		22

usr.bin/ssh/mux.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: mux.c,v 1.102 2024/07/25 22:40:08 djm Exp $ */
+/* $OpenBSD: mux.c,v 1.103 2024/10/12 10:50:37 jsg Exp $ */
 /*
  * Copyright (c) 2002-2008 Damien Miller <djm@openbsd.org>
  *
@@ -55,7 +55,6 @@
 #include "readconf.h"
 #include "clientloop.h"
 #include "ssherr.h"
-#include "misc.h"
 
 /* from ssh.c */
 extern int tty_flag;

usr.bin/tmux/cmd-source-file.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-source-file.c,v 1.54 2023/09/15 06:31:49 nicm Exp $ */
+/* $OpenBSD: cmd-source-file.c,v 1.55 2024/10/12 08:20:32 nicm Exp $ */
 
 /*
  * Copyright (c) 2008 Tiago Cunha <me@tiagocunha.org>
@@ -122,6 +122,14 @@ cmd_source_file_done(struct client *c, const char *path, int error,
 static void
 cmd_source_file_add(struct cmd_source_file_data *cdata, const char *path)
 {
+	char	resolved[PATH_MAX];
+
+	if (realpath(path, resolved) == NULL) {
+		log_debug("%s: realpath(\"%s\") failed: %s", __func__,
+			path, strerror(errno));
+	} else
+		path = resolved;
+
 	log_debug("%s: %s", __func__, path);
 	cdata->files = xreallocarray(cdata->files, cdata->nfiles + 1,
 	    sizeof *cdata->files);

usr.bin/tmux/paste.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: paste.c,v 1.46 2023/02/07 10:56:04 nicm Exp $ */
+/* $OpenBSD: paste.c,v 1.47 2024/10/12 08:13:52 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -241,6 +241,8 @@ paste_rename(const char *oldname, const char *newname, char **cause)
 	}
 
 	pb_new = paste_get_name(newname);
+	if (pb_new == pb)
+		return (0);
 	if (pb_new != NULL)
 		paste_free(pb_new);
 

usr.sbin/sysupgrade/sysupgrade.8

@@ -1,4 +1,4 @@
-.\"	$OpenBSD: sysupgrade.8,v 1.20 2024/10/07 15:57:15 jmc Exp $
+.\"	$OpenBSD: sysupgrade.8,v 1.21 2024/10/11 14:12:05 deraadt Exp $
 .\"
 .\" Copyright (c) 2019 Florian Obser <florian@openbsd.org>
 .\"
@@ -14,7 +14,7 @@
 .\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 .\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 .\"
-.Dd $Mdocdate: October 7 2024 $
+.Dd $Mdocdate: October 11 2024 $
 .Dt SYSUPGRADE 8
 .Os
 .Sh NAME
@@ -76,10 +76,10 @@ The default is to upgrade to the next release.
 .El
 .Pp
 When updating to a release or snapshot which lacks the required signify
-key in
+keys in
 .Pa /etc/signify ,
-the missing key will be downloaded in a secure way.
+the missing keys will be downloaded in a secure way.
-In the usual case, the key will already be present because
+In the usual case, the keys will already be present because
 .Ox
 releases ship with the current key, the next key, and a collection of
 older keys.

usr.sbin/sysupgrade/sysupgrade.sh

@@ -1,6 +1,6 @@
 #!/bin/ksh
 #
-# $OpenBSD: sysupgrade.sh,v 1.55 2024/10/07 13:21:53 deraadt Exp $
+# $OpenBSD: sysupgrade.sh,v 1.56 2024/10/11 14:12:05 deraadt Exp $
 #
 # Copyright (c) 1997-2015 Todd Miller, Theo de Raadt, Ken Westerback
 # Copyright (c) 2015 Robert Peichaer <rpe@openbsd.org>
@@ -153,9 +153,10 @@ if ! [[ -r /etc/signify/$KEY ]]; then
 	HAVEKEY=$(cd /etc/signify && ls -1 secbsd-*-base.pub | \
 	    tail -2 | head -1 | cut -d- -f2)
 	BUNDLE=sigbundle-${HAVEKEY}.tgz
-	echo "Adding additional key $KEY from bundle $BUNDLE"
+	FWKEY=$(echo $KEY | sed -e 's/base/fw/')
+	echo "Adding missing keys from bundle $BUNDLE"
 	unpriv -f ${BUNDLE} ftp -N sysupgrade -Vmo $BUNDLE https://ftp.secbsd.org/pub/SecBSD/signify/$BUNDLE
-	signify -Vzq -m - -x $BUNDLE | (cd /etc/signify && tar xfz - $KEY)
+	signify -Vzq -m - -x $BUNDLE | (cd /etc/signify && tar xfz - $KEY $FWKEY)
 	rm $BUNDLE
 fi