File xterm-CVE-2022-45063.patch of Package xterm

Overview Repositories Revisions Requests Users Attributes Meta

File xterm-CVE-2022-45063.patch of Package xterm (Revision f41fdf2806690f9bf254baa39955e43e)

Currently displaying revision f41fdf2806690f9bf254baa39955e43e , Show latest

From 787636674918873a091e7a4ef5977263ba982322 Mon Sep 17 00:00:00 2001
From: "Thomas E. Dickey" <dickey@invisible-island.net>
Date: Sun, 23 Oct 2022 22:59:52 +0000
Subject: [PATCH] snapshot of project "xterm", label xterm-374c

Index: xterm-308/button.c
===================================================================
--- xterm-308.orig/button.c
+++ xterm-308/button.c
@@ -1555,8 +1555,6 @@ UnmapSelections(XtermWidget xw)
     Cardinal n;
 
     if (screen->mappedSelect) {
-	for (n = 0; screen->mappedSelect[n] != 0; ++n)
-	    free((void *) screen->mappedSelect[n]);
 	free(screen->mappedSelect);
 	screen->mappedSelect = 0;
     }
@@ -1595,14 +1593,11 @@ MapSelections(XtermWidget xw, String *pa
 	    if ((result = TypeMallocN(String, num_params + 1)) != 0) {
 		result[num_params] = 0;
 		for (j = 0; j < num_params; ++j) {
-		    result[j] = x_strdup((isSELECT(params[j])
+		    result[j] = (String)(isSELECT(params[j])
 					  ? mapTo
-					  : params[j]));
+					  : params[j]);
 		    if (result[j] == 0) {
 			UnmapSelections(xw);
-			while (j != 0) {
-			    free((void *) result[--j]);
-			}
 			free(result);
 			result = 0;
 			break;
Index: xterm-308/charproc.c
===================================================================
--- xterm-308.orig/charproc.c
+++ xterm-308/charproc.c
@@ -10750,7 +10750,6 @@ DoSetSelectedFont(Widget w,
 	Bell(xw, XkbBI_MinorError, 0);
     } else {
 	Boolean failed = False;
-	int oldFont = TScreenOf(xw)->menu_font_number;
 	String save = TScreenOf(xw)->MenuFontName(fontMenu_fontsel);
 	char *val;
 	char *test = 0;
@@ -10794,10 +10793,6 @@ DoSetSelectedFont(Widget w,
 		failed = True;
 	    }
 	    if (failed) {
-		(void) xtermLoadFont(term,
-				     xtermFontName(TScreenOf(xw)->MenuFontName(oldFont)),
-				     True,
-				     oldFont);
 		Bell(xw, XkbBI_MinorError, 0);
 	    }
 	    free(used);
@@ -10806,7 +10801,7 @@ DoSetSelectedFont(Widget w,
     }
 }
 
-void
+Bool
 FindFontSelection(XtermWidget xw, const char *atom_name, Bool justprobe)
 {
     TScreen *screen = TScreenOf(xw);
@@ -10846,7 +10841,8 @@ FindFontSelection(XtermWidget xw, const
 			    DoSetSelectedFont, NULL,
 			    XtLastTimestampProcessed(XtDisplay(xw)));
     }
-    return;
+    
+    return (screen->MenuFontName(fontMenu_fontsel) != NULL) ? True : False;
 }
 
 Bool
Index: xterm-308/doublechr.c
===================================================================
--- xterm-308.orig/doublechr.c
+++ xterm-308/doublechr.c
@@ -294,7 +294,7 @@ xterm_DoubleGC(XtermWidget xw,
 	    temp.chrset = chrset;
 	    temp.flags = (attr_flags & BOLD);
 
-	    if (!xtermOpenFont(xw, name, &temp, fwAlways, False)) {
+	    if (!xtermOpenFont(xw, name, &temp, fwAlways, NULL, False)) {
 		/* Retry with * in resolutions */
 		char *nname = xtermSpecialFont(screen,
 					       attr_flags,
@@ -303,7 +303,7 @@ xterm_DoubleGC(XtermWidget xw,
 
 		if (nname != 0) {
 		    found = (Boolean) xtermOpenFont(xw, nname, &temp,
-						    fwAlways, False);
+						    fwAlways, NULL, False);
 		    free(nname);
 		}
 	    } else {
Index: xterm-308/fontutils.c
===================================================================
--- xterm-308.orig/fontutils.c
+++ xterm-308/fontutils.c
@@ -96,9 +96,9 @@
 }
 
 #define FREE_FNAME(field) \
-	    if (fonts == 0 || myfonts.field != fonts->field) { \
-		FREE_STRING(myfonts.field); \
-		myfonts.field = 0; \
+	    if (fonts == 0 || new_fnames.field != fonts->field) { \
+		FREE_STRING(new_fnames.field); \
+		new_fnames.field = 0; \
 	    }
 
 /*
@@ -769,12 +769,17 @@ xtermOpenFont(XtermWidget xw,
 	      const char *name,
 	      XTermFonts * result,
 	      fontWarningTypes warn,
+	      XTermFonts * current,
 	      Bool force)
 {
     Bool code = False;
     TScreen *screen = TScreenOf(xw);
 
     if (!IsEmpty(name)) {
+	Bool existing = (current != NULL
+		&& current->fs != NULL
+		&& current->fn != NULL);
+
 	if ((result->fs = XLoadQueryFont(screen->display, name)) != 0) {
 	    code = True;
 	    if (EmptyFont(result->fs)) {
@@ -804,8 +809,12 @@ xtermOpenFont(XtermWidget xw,
 	    } else {
 		TRACE(("xtermOpenFont: cannot load font '%s'\n", name));
 	    }
-	    if (force) {
-		code = xtermOpenFont(xw, DEFFONT, result, fwAlways, True);
+	    if (existing) {
+		TRACE(("...continue using font '%s'\n", current->fn));
+		result->fn = x_strdup(current->fn);
+		result->fs = current->fs;
+	    } else if (force) {
+		code = xtermOpenFont(xw, DEFFONT, result, fwAlways, NULL, True);
 	    }
 	}
     }
@@ -1019,31 +1028,41 @@ show_font_misses(const char *name, XTerm
 }
 #endif
 
+/*
+ * Load a given bitmap font, along with the bold/wide variants.
+ * Returns nonzero on success.
+ */
 int
 xtermLoadFont(XtermWidget xw,
 	      const VTFontNames * fonts,
 	      Bool doresize,
-	      int fontnum)
+	      int fontnum
+	      )
 {
     TScreen *screen = TScreenOf(xw);
     VTwin *win = WhichVWin(screen);
 
-    VTFontNames myfonts;
+    VTFontNames new_fnames;
     FontNameProperties *fp;
-    XTermFonts fnts[fMAX];
+    XTermFonts new_fnts[fMAX];
+    XTermFonts old_fnts[fMAX];
     char *tmpname = NULL;
     char *normal = NULL;
     Boolean proportional = False;
     fontWarningTypes warn[fMAX];
     int j;
+    Boolean recovered;
+    int code = 0;
 
-    memset(&myfonts, 0, sizeof(myfonts));
-    memset(fnts, 0, sizeof(fnts));
+
+    memset(&new_fnames, 0, sizeof(new_fnames));
+    memset(new_fnts, 0, sizeof(new_fnts));
+    memcpy(&old_fnts, screen->fnts, sizeof(old_fnts));
 
     if (fonts != 0)
-	myfonts = *fonts;
-    if (!check_fontname(myfonts.f_n))
-	return 0;
+	new_fnames = *fonts;
+    if (!check_fontname(new_fnames.f_n))
+	return code;
 
     /*
      * Check the font names against the resource values, to see which were
@@ -1054,7 +1073,7 @@ xtermLoadFont(XtermWidget xw,
 	warn[j] = fwAlways;
     }
 #define CmpResource(field, index) \
-    if (same_font_name(screen->menu_font_names[fontnum][index], myfonts.field)) \
+    if (same_font_name(screen->menu_font_names[fontnum][index], new_fnames.field)) \
 	warn[index] = fwResource
 
     CmpResource(f_n, fNorm);
@@ -1067,19 +1086,19 @@ xtermLoadFont(XtermWidget xw,
     }
 
     if (fontnum == fontMenu_fontescape
-	&& myfonts.f_n != screen->MenuFontName(fontnum)) {
-	if ((tmpname = x_strdup(myfonts.f_n)) == 0)
-	    return 0;
+	&& new_fnames.f_n != screen->MenuFontName(fontnum)) {
+	if ((tmpname = x_strdup(new_fnames.f_n)) == 0)
+	    return code;
     }
 
-    TRACE(("Begin Cgs - xtermLoadFont(%s)\n", myfonts.f_n));
+    TRACE(("Begin Cgs - xtermLoadFont(%s)\n", new_fnames.f_n));
     releaseWindowGCs(xw, win);
 
 #define DbgResource(name, field, index) \
     TRACE(("xtermLoadFont #%d "name" %s%s\n", \
     	   fontnum, \
 	   (warn[index] == fwResource) ? "*" : " ", \
-	   NonNull(myfonts.field)))
+	   NonNull(new_fnames.field)))
     DbgResource("normal", f_n, fNorm);
     DbgResource("bold  ", f_b, fBold);
 #if OPT_WIDE_CHARS
@@ -1093,47 +1112,48 @@ xtermLoadFont(XtermWidget xw,
      * the font, disable it from the menu.
      */
     if (!xtermOpenFont(xw,
-		       myfonts.f_n,
-		       &fnts[fNorm],
+		       new_fnames.f_n,
+		       &new_fnts[fNorm],
 		       warn[fNorm],
+		       &old_fnts[fNorm],
 		       (fontnum == fontMenu_default))) {
 	SetItemSensitivity(fontMenuEntries[fontnum].widget, False);
 	goto bad;
     }
 
-    normal = x_strdup(myfonts.f_n);
-    if (!check_fontname(myfonts.f_b)) {
+    normal = x_strdup(new_fnames.f_n);
+    if (!check_fontname(new_fnames.f_b)) {
 	warn[fBold] = fwAlways;
-	fp = get_font_name_props(screen->display, fnts[fNorm].fs, &normal);
+	fp = get_font_name_props(screen->display, new_fnts[fNorm].fs, &normal);
 	if (fp != 0) {
 	    FREE_FNAME(f_b);
-	    myfonts.f_b = bold_font_name(fp, fp->average_width);
-	    if (!xtermOpenFont(xw, myfonts.f_b, &fnts[fBold], fwAlways, False)) {
+	    new_fnames.f_b = bold_font_name(fp, fp->average_width);
+	    if (!xtermOpenFont(xw, new_fnames.f_b, &new_fnts[fBold], fwAlways, NULL, False)) {
 		FREE_FNAME(f_b);
-		myfonts.f_b = bold_font_name(fp, -1);
-		xtermOpenFont(xw, myfonts.f_b, &fnts[fBold], fwAlways, False);
+		new_fnames.f_b = bold_font_name(fp, -1);
+		xtermOpenFont(xw, new_fnames.f_b, &new_fnts[fBold], fwAlways, NULL, False);
 	    }
-	    TRACE(("...derived bold '%s'\n", NonNull(myfonts.f_b)));
+	    TRACE(("...derived bold '%s'\n", NonNull(new_fnames.f_b)));
 	}
-	if (fp == 0 || fnts[fBold].fs == 0) {
-	    xtermCopyFontInfo(&fnts[fBold], &fnts[fNorm]);
+	if (fp == 0 || new_fnts[fBold].fs == 0) {
+	    xtermCopyFontInfo(&new_fnts[fBold], &new_fnts[fNorm]);
 	    TRACE(("...cannot load a matching bold font\n"));
-	} else if (comparable_metrics(fnts[fNorm].fs, fnts[fBold].fs)
-		   && same_font_size(xw, fnts[fNorm].fs, fnts[fBold].fs)
-		   && got_bold_font(screen->display, fnts[fBold].fs, myfonts.f_b)) {
+	} else if (comparable_metrics(new_fnts[fNorm].fs, new_fnts[fBold].fs)
+		   && same_font_size(xw, new_fnts[fNorm].fs, new_fnts[fBold].fs)
+		   && got_bold_font(screen->display, new_fnts[fBold].fs, new_fnames.f_b)) {
 	    TRACE(("...got a matching bold font\n"));
-	    cache_menu_font_name(screen, fontnum, fBold, myfonts.f_b);
+	    cache_menu_font_name(screen, fontnum, fBold, new_fnames.f_b);
 	} else {
-	    xtermCloseFont(xw, &fnts[fBold]);
-	    fnts[fBold] = fnts[fNorm];
+	    xtermCloseFont(xw, &new_fnts[fBold]);
+	    new_fnts[fBold] = new_fnts[fNorm];
 	    TRACE(("...did not get a matching bold font\n"));
 	}
-    } else if (!xtermOpenFont(xw, myfonts.f_b, &fnts[fBold], warn[fBold], False)) {
-	xtermCopyFontInfo(&fnts[fBold], &fnts[fNorm]);
+    } else if (!xtermOpenFont(xw, new_fnames.f_b, &new_fnts[fBold], warn[fBold], NULL, False)) {
+	xtermCopyFontInfo(&new_fnts[fBold], &new_fnts[fNorm]);
 	warn[fBold] = fwAlways;
-	TRACE(("...cannot load bold font '%s'\n", NonNull(myfonts.f_b)));
+	TRACE(("...cannot load bold font '%s'\n", NonNull(new_fnames.f_b)));
     } else {
-	cache_menu_font_name(screen, fontnum, fBold, myfonts.f_b);
+	cache_menu_font_name(screen, fontnum, fBold, new_fnames.f_b);
     }
 
     /*
@@ -1145,84 +1165,85 @@ xtermLoadFont(XtermWidget xw,
 	Boolean derived;
 	char *bold = NULL;
 
-	if (check_fontname(myfonts.f_w)) {
-	    cache_menu_font_name(screen, fontnum, fWide, myfonts.f_w);
-	} else if (screen->utf8_fonts && !is_double_width_font(fnts[fNorm].fs)) {
+	if (check_fontname(new_fnames.f_w)) {
+	    cache_menu_font_name(screen, fontnum, fWide, new_fnames.f_w);
+	} else if (screen->utf8_fonts && !is_double_width_font(new_fnts[fNorm].fs)) {
 	    FREE_FNAME(f_w);
-	    fp = get_font_name_props(screen->display, fnts[fNorm].fs, &normal);
+	    fp = get_font_name_props(screen->display, new_fnts[fNorm].fs, &normal);
 	    if (fp != 0) {
-		myfonts.f_w = wide_font_name(fp);
+		new_fnames.f_w = wide_font_name(fp);
 		warn[fWide] = fwAlways;
-		TRACE(("...derived wide %s\n", NonNull(myfonts.f_w)));
-		cache_menu_font_name(screen, fontnum, fWide, myfonts.f_w);
+		TRACE(("...derived wide %s\n", NonNull(new_fnames.f_w)));
+		cache_menu_font_name(screen, fontnum, fWide, new_fnames.f_w);
 	    }
 	}
 
-	if (check_fontname(myfonts.f_w)) {
-	    (void) xtermOpenFont(xw, myfonts.f_w, &fnts[fWide], warn[fWide], False);
+	if (check_fontname(new_fnames.f_w)) {
+	    (void) xtermOpenFont(xw, new_fnames.f_w, &new_fnts[fWide], warn[fWide], NULL, False);
 	} else {
-	    xtermCopyFontInfo(&fnts[fWide], &fnts[fNorm]);
+	    xtermCopyFontInfo(&new_fnts[fWide], &new_fnts[fNorm]);
 	    warn[fWide] = fwAlways;
 	}
 
 	derived = False;
-	if (!check_fontname(myfonts.f_wb)) {
-	    fp = get_font_name_props(screen->display, fnts[fBold].fs, &bold);
+	if (!check_fontname(new_fnames.f_wb)) {
+	    fp = get_font_name_props(screen->display, new_fnts[fBold].fs, &bold);
 	    if (fp != 0) {
-		myfonts.f_wb = widebold_font_name(fp);
+		new_fnames.f_wb = widebold_font_name(fp);
 		warn[fWBold] = fwAlways;
 		derived = True;
 	    }
 	}
 
-	if (check_fontname(myfonts.f_wb)) {
+	if (check_fontname(new_fnames.f_wb)) {
 
 	    xtermOpenFont(xw,
-			  myfonts.f_wb,
-			  &fnts[fWBold],
+			  new_fnames.f_wb,
+			  &new_fnts[fWBold],
 			  (screen->utf8_fonts
 			   ? warn[fWBold]
 			   : (fontWarningTypes) (xw->misc.fontWarnings + 1)),
+			  NULL,
 			  False);
 
 	    if (derived
-		&& !compatibleWideCounts(fnts[fWide].fs, fnts[fWBold].fs)) {
-		xtermCloseFont(xw, &fnts[fWBold]);
+		&& !compatibleWideCounts(new_fnts[fWide].fs, new_fnts[fWBold].fs)) {
+		xtermCloseFont(xw, &new_fnts[fWBold]);
 	    }
-	    if (fnts[fWBold].fs == 0) {
+	    if (new_fnts[fWBold].fs == 0) {
 		FREE_FNAME(f_wb);
-		if (IsEmpty(myfonts.f_w)) {
-		    myfonts.f_wb = x_strdup(myfonts.f_b);
+		if (IsEmpty(new_fnames.f_w)) {
+		    new_fnames.f_wb = x_strdup(new_fnames.f_b);
 		    warn[fWBold] = fwAlways;
-		    xtermCopyFontInfo(&fnts[fWBold], &fnts[fBold]);
+		    xtermCopyFontInfo(&new_fnts[fWBold], &new_fnts[fBold]);
 		    TRACE(("...cannot load wide-bold, use bold %s\n",
-			   NonNull(myfonts.f_b)));
+			   NonNull(new_fnames.f_b)));
 		} else {
-		    myfonts.f_wb = x_strdup(myfonts.f_w);
+		    new_fnames.f_wb = x_strdup(new_fnames.f_w);
 		    warn[fWBold] = fwAlways;
-		    xtermCopyFontInfo(&fnts[fWBold], &fnts[fWide]);
+		    xtermCopyFontInfo(&new_fnts[fWBold], &new_fnts[fWide]);
 		    TRACE(("...cannot load wide-bold, use wide %s\n",
-			   NonNull(myfonts.f_w)));
+			   NonNull(new_fnames.f_w)));
 		}
 	    } else {
 		TRACE(("...%s wide/bold %s\n",
 		       derived ? "derived" : "given",
-		       NonNull(myfonts.f_wb)));
-		cache_menu_font_name(screen, fontnum, fWBold, myfonts.f_wb);
+		       NonNull(new_fnames.f_wb)));
+		cache_menu_font_name(screen, fontnum, fWBold, new_fnames.f_wb);
 	    }
-	} else if (is_double_width_font(fnts[fBold].fs)) {
-	    xtermCopyFontInfo(&fnts[fWBold], &fnts[fBold]);
+	} else if (is_double_width_font(new_fnts[fBold].fs)) {
+	    xtermCopyFontInfo(&new_fnts[fWBold], &new_fnts[fBold]);
 	    warn[fWBold] = fwAlways;
-	    TRACE(("...bold font is double-width, use it %s\n", NonNull(myfonts.f_b)));
+	    TRACE(("...bold font is double-width, use it %s\n", NonNull(new_fnames.f_b)));
 	} else {
-	    xtermCopyFontInfo(&fnts[fWBold], &fnts[fWide]);
+	    xtermCopyFontInfo(&new_fnts[fWBold], &new_fnts[fWide]);
 	    warn[fWBold] = fwAlways;
-	    TRACE(("...cannot load wide bold font, use wide %s\n", NonNull(myfonts.f_w)));
+	    TRACE(("...cannot load wide bold font, use wide %s\n", NonNull(new_fnames.f_w)));
 	}
 
 	free(bold);
 
-	if (EmptyFont(fnts[fWBold].fs))
+	if (EmptyFont(new_fnts[fWBold].fs))
 	    goto bad;		/* can't use a 0-sized font */
     });
 
@@ -1233,26 +1254,26 @@ xtermLoadFont(XtermWidget xw,
      *
      * But if it did fail for some reason, then nevermind.
      */
-    if (EmptyFont(fnts[fBold].fs))
+    if (EmptyFont(new_fnts[fBold].fs))
 	goto bad;		/* can't use a 0-sized font */
 
-    if (!same_font_size(xw, fnts[fNorm].fs, fnts[fBold].fs)
-	&& (is_fixed_font(fnts[fNorm].fs) && is_fixed_font(fnts[fBold].fs))) {
+    if (!same_font_size(xw, new_fnts[fNorm].fs, new_fnts[fBold].fs)
+	&& (is_fixed_font(new_fnts[fNorm].fs) && is_fixed_font(new_fnts[fBold].fs))) {
 	TRACE(("...ignoring mismatched normal/bold fonts\n"));
-	xtermCloseFont(xw, &fnts[fBold]);
-	xtermCopyFontInfo(&fnts[fBold], &fnts[fNorm]);
+	xtermCloseFont(xw, &new_fnts[fBold]);
+	xtermCopyFontInfo(&new_fnts[fBold], &new_fnts[fNorm]);
     }
 
     if_OPT_WIDE_CHARS(screen, {
-	if (fnts[fWide].fs != 0
-	    && fnts[fWBold].fs != 0
-	    && (!comparable_metrics(fnts[fWide].fs, fnts[fWBold].fs)
-		|| (!same_font_size(xw, fnts[fWide].fs, fnts[fWBold].fs)
-		    && is_fixed_font(fnts[fWide].fs)
-		    && is_fixed_font(fnts[fWBold].fs)))) {
+	if (new_fnts[fWide].fs != 0
+	    && new_fnts[fWBold].fs != 0
+	    && (!comparable_metrics(new_fnts[fWide].fs, new_fnts[fWBold].fs)
+		|| (!same_font_size(xw, new_fnts[fWide].fs, new_fnts[fWBold].fs)
+		    && is_fixed_font(new_fnts[fWide].fs)
+		    && is_fixed_font(new_fnts[fWBold].fs)))) {
 	    TRACE(("...ignoring mismatched normal/bold wide fonts\n"));
-	    xtermCloseFont(xw, &fnts[fWBold]);
-	    xtermCopyFontInfo(&fnts[fWBold], &fnts[fWide]);
+	    xtermCloseFont(xw, &new_fnts[fWBold]);
+	    xtermCopyFontInfo(&new_fnts[fWBold], &new_fnts[fWide]);
 	}
     });
 
@@ -1260,28 +1281,28 @@ xtermLoadFont(XtermWidget xw,
      * Normal/bold fonts should be the same width.  Also, the min/max
      * values should be the same.
      */
-    if (!is_fixed_font(fnts[fNorm].fs)
-	|| !is_fixed_font(fnts[fBold].fs)
-	|| fnts[fNorm].fs->max_bounds.width != fnts[fBold].fs->max_bounds.width) {
+    if (!is_fixed_font(new_fnts[fNorm].fs)
+	|| !is_fixed_font(new_fnts[fBold].fs)
+	|| new_fnts[fNorm].fs->max_bounds.width != new_fnts[fBold].fs->max_bounds.width) {
 	TRACE(("Proportional font! normal %d/%d, bold %d/%d\n",
-	       fnts[fNorm].fs->min_bounds.width,
-	       fnts[fNorm].fs->max_bounds.width,
-	       fnts[fBold].fs->min_bounds.width,
-	       fnts[fBold].fs->max_bounds.width));
+	       new_fnts[fNorm].fs->min_bounds.width,
+	       new_fnts[fNorm].fs->max_bounds.width,
+	       new_fnts[fBold].fs->min_bounds.width,
+	       new_fnts[fBold].fs->max_bounds.width));
 	proportional = True;
     }
 
     if_OPT_WIDE_CHARS(screen, {
-	if (fnts[fWide].fs != 0
-	    && fnts[fWBold].fs != 0
-	    && (!is_fixed_font(fnts[fWide].fs)
-		|| !is_fixed_font(fnts[fWBold].fs)
-		|| fnts[fWide].fs->max_bounds.width != fnts[fWBold].fs->max_bounds.width)) {
+	if (new_fnts[fWide].fs != 0
+	    && new_fnts[fWBold].fs != 0
+	    && (!is_fixed_font(new_fnts[fWide].fs)
+		|| !is_fixed_font(new_fnts[fWBold].fs)
+		|| new_fnts[fWide].fs->max_bounds.width != new_fnts[fWBold].fs->max_bounds.width)) {
 	    TRACE(("Proportional font! wide %d/%d, wide bold %d/%d\n",
-		   fnts[fWide].fs->min_bounds.width,
-		   fnts[fWide].fs->max_bounds.width,
-		   fnts[fWBold].fs->min_bounds.width,
-		   fnts[fWBold].fs->max_bounds.width));
+		   new_fnts[fWide].fs->min_bounds.width,
+		   new_fnts[fWide].fs->max_bounds.width,
+		   new_fnts[fWBold].fs->min_bounds.width,
+		   new_fnts[fWBold].fs->max_bounds.width));
 	    proportional = True;
 	}
     });
@@ -1300,13 +1321,13 @@ xtermLoadFont(XtermWidget xw,
     screen->ifnts_ok = False;
 #endif
 
-    xtermCopyFontInfo(&(screen->fnts[fNorm]), &fnts[fNorm]);
-    xtermCopyFontInfo(&(screen->fnts[fBold]), &fnts[fBold]);
+    xtermCopyFontInfo(&(screen->fnts[fNorm]), &new_fnts[fNorm]);
+    xtermCopyFontInfo(&(screen->fnts[fBold]), &new_fnts[fBold]);
 #if OPT_WIDE_CHARS
-    xtermCopyFontInfo(&(screen->fnts[fWide]), &fnts[fWide]);
-    if (fnts[fWBold].fs == NULL)
-	xtermCopyFontInfo(&fnts[fWBold], &fnts[fWide]);
-    xtermCopyFontInfo(&(screen->fnts[fWBold]), &fnts[fWBold]);
+    xtermCopyFontInfo(&(screen->fnts[fWide]), &new_fnts[fWide]);
+    if (new_fnts[fWBold].fs == NULL)
+	xtermCopyFontInfo(&new_fnts[fWBold], &new_fnts[fWide]);
+    xtermCopyFontInfo(&(screen->fnts[fWBold]), &new_fnts[fWBold]);
 #endif
 
     xtermUpdateFontGCs(xw, screen->fnts);
@@ -1337,7 +1358,7 @@ xtermLoadFont(XtermWidget xw,
 	unsigned ch;
 
 #if OPT_TRACE
-#define TRACE_MISS(index) show_font_misses(#index, &fnts[index])
+#define TRACE_MISS(index) show_font_misses(#index, &new_fnts[index])
 	TRACE_MISS(fNorm);
 	TRACE_MISS(fBold);
 #if OPT_WIDE_CHARS
@@ -1355,12 +1376,12 @@ xtermLoadFont(XtermWidget xw,
 		    continue;
 	    }
 #endif
-	    if (IsXtermMissingChar(screen, n, &fnts[fNorm])) {
+	    if (IsXtermMissingChar(screen, n, &new_fnts[fNorm])) {
 		TRACE(("missing normal char #%d\n", n));
 		screen->fnt_boxes = False;
 		break;
 	    }
-	    if (IsXtermMissingChar(screen, n, &fnts[fBold])) {
+	    if (IsXtermMissingChar(screen, n, &new_fnts[fBold])) {
 		TRACE(("missing bold char #%d\n", n));
 		screen->fnt_boxes = False;
 		break;
@@ -1375,8 +1396,8 @@ xtermLoadFont(XtermWidget xw,
 	screen->enbolden = screen->bold_mode;
     } else {
 	screen->enbolden = screen->bold_mode
-	    && ((fnts[fNorm].fs == fnts[fBold].fs)
-		|| same_font_name(normal, myfonts.f_b));
+	    && ((new_fnts[fNorm].fs == new_fnts[fBold].fs)
+		|| same_font_name(normal, new_fnames.f_b));
     }
     TRACE(("Will %suse 1-pixel offset/overstrike to simulate bold\n",
 	   screen->enbolden ? "" : "not "));
@@ -1393,7 +1414,7 @@ xtermLoadFont(XtermWidget xw,
 			       True);
 	}
 #if OPT_SHIFT_FONTS
-	screen->menu_font_sizes[fontnum] = FontSize(fnts[fNorm].fs);
+	screen->menu_font_sizes[fontnum] = FontSize(new_fnts[fNorm].fs);
 #endif
     }
     if (normal)
@@ -1410,19 +1431,20 @@ xtermLoadFont(XtermWidget xw,
     FREE_FNAME(f_w);
     FREE_FNAME(f_wb);
 #endif
-    if (fnts[fNorm].fn == fnts[fBold].fn) {
-	free(fnts[fNorm].fn);
+    if (new_fnts[fNorm].fn == new_fnts[fBold].fn) {
+	free(new_fnts[fNorm].fn);
     } else {
-	free(fnts[fNorm].fn);
-	free(fnts[fBold].fn);
+	free(new_fnts[fNorm].fn);
+	free(new_fnts[fBold].fn);
     }
 #if OPT_WIDE_CHARS
-    free(fnts[fWide].fn);
-    free(fnts[fWBold].fn);
+    free(new_fnts[fWide].fn);
+    free(new_fnts[fWBold].fn);
 #endif
     return 1;
 
   bad:
+    recovered = False;
     if (normal)
 	free(normal);
     if (tmpname)
@@ -1435,30 +1457,31 @@ xtermLoadFont(XtermWidget xw,
 	SetItemSensitivity(fontMenuEntries[fontnum].widget, True);
 #endif
 	Bell(xw, XkbBI_MinorError, 0);
-	myfonts.f_n = screen->MenuFontName(old_fontnum);
-	return xtermLoadFont(xw, &myfonts, doresize, old_fontnum);
-    } else if (x_strcasecmp(myfonts.f_n, DEFFONT)) {
-	int code;
-
-	myfonts.f_n = DEFFONT;
-	TRACE(("...recovering for TrueType fonts\n"));
-	code = xtermLoadFont(xw, &myfonts, doresize, fontnum);
-	if (code) {
-	    SetItemSensitivity(fontMenuEntries[fontnum].widget,
+	new_fnames.f_n = screen->MenuFontName(old_fontnum);
+	if (xtermLoadFont(xw, &new_fnames, doresize, old_fontnum))
+		recovered = True;
+    } else if (x_strcasecmp(new_fnames.f_n, DEFFONT)
+	&& x_strcasecmp(new_fnames.f_n, old_fnts[fNorm].fn)) {
+	new_fnames.f_n = x_strdup(old_fnts[fNorm].fn);
+
+	TRACE(("...recovering from failed font-load\n"));
+	if (xtermLoadFont(xw, &new_fnames, doresize, fontnum)) {
+		recovered = True;
+	    	SetItemSensitivity(fontMenuEntries[fontnum].widget,
 			       UsingRenderFont(xw));
-	    TRACE(("...recovered size %dx%d\n",
+	    	TRACE(("...recovered size %dx%d\n",
 		   FontHeight(screen),
 		   FontWidth(screen)));
 	}
-	return code;
     }
 #endif
-
-    releaseWindowGCs(xw, win);
-
-    xtermCloseFonts(xw, fnts);
-    TRACE(("Fail Cgs - xtermLoadFont\n"));
-    return 0;
+    if (!recovered) {
+	releaseWindowGCs(xw, win);
+	xtermCloseFonts(xw, new_fnts);
+	TRACE(("Fail Cgs - xtermLoadFont\n"));
+	code = 0;
+    }
+    return code;
 }
 
 #if OPT_WIDE_ATTRS
@@ -1491,6 +1514,7 @@ xtermLoadItalics(XtermWidget xw)
 					 name,
 					 &(screen->ifnts[n]),
 					 fwResource,
+					 NULL,
 					 False);
 #if OPT_TRACE
 		    {
@@ -3064,6 +3088,7 @@ lookupOneFontSize(XtermWidget xw, int fo
 			  ((fontnum <= fontMenu_lastBuiltin)
 			   ? fwAlways
 			   : fwResource),
+			  NULL,
 			  True)) {
 	    if (fontnum <= fontMenu_lastBuiltin
 		|| strcmp(fnt.fn, DEFFONT)) {
@@ -3465,13 +3490,14 @@ HandleSetFont(Widget w GCC_UNUSED,
     }
 }
 
-void
+Bool
 SetVTFont(XtermWidget xw,
 	  int which,
 	  Bool doresize,
 	  const VTFontNames * fonts)
 {
     TScreen *screen = TScreenOf(xw);
+    Bool result = False;
 
     TRACE(("SetVTFont(which=%d, f_n=%s, f_b=%s)\n", which,
 	   (fonts && fonts->f_n) ? fonts->f_n : "<null>",
@@ -3480,33 +3506,31 @@ SetVTFont(XtermWidget xw,
     if (IsIcon(screen)) {
 	Bell(xw, XkbBI_MinorError, 0);
     } else if (which >= 0 && which < NMENUFONTS) {
-	VTFontNames myfonts;
+	VTFontNames new_fnames;
 
-	memset(&myfonts, 0, sizeof(myfonts));
+	memset(&new_fnames, 0, sizeof(new_fnames));
 	if (fonts != 0)
-	    myfonts = *fonts;
+	    new_fnames = *fonts;
 
 	if (which == fontMenu_fontsel) {	/* go get the selection */
-	    FindFontSelection(xw, myfonts.f_n, False);
+	    result = FindFontSelection(xw, new_fnames.f_n, False);
 	} else {
-	    int oldFont = screen->menu_font_number;
-
 #define USE_CACHED(field, name) \
-	    if (myfonts.field == 0) { \
-		myfonts.field = x_strdup(screen->menu_font_names[which][name]); \
-		TRACE(("set myfonts." #field " from menu_font_names[%d][" #name "] %s\n", \
-		       which, NonNull(myfonts.field))); \
+	    if (new_fnames.field == 0) { \
+		new_fnames.field = x_strdup(screen->menu_font_names[which][name]); \
+		TRACE(("set new_fnames." #field " from menu_font_names[%d][" #name "] %s\n", \
+		       which, NonNull(new_fnames.field))); \
 	    } else { \
-		TRACE(("set myfonts." #field " reused\n")); \
+		TRACE(("set new_fnames." #field " reused\n")); \
 	    }
 #define SAVE_FNAME(field, name) \
-	    if (myfonts.field != 0) { \
+	    if (new_fnames.field != 0) { \
 		if (screen->menu_font_names[which][name] == 0 \
-		 || strcmp(screen->menu_font_names[which][name], myfonts.field)) { \
+		 || strcmp(screen->menu_font_names[which][name], new_fnames.field)) { \
 		    TRACE(("updating menu_font_names[%d][" #name "] to %s\n", \
-			   which, myfonts.field)); \
+			   which, new_fnames.field)); \
 		    FREE_STRING(screen->menu_font_names[which][name]); \
-		    screen->menu_font_names[which][name] = x_strdup(myfonts.field); \
+		    screen->menu_font_names[which][name] = x_strdup(new_fnames.field); \
 		} \
 	    }
 
@@ -3517,7 +3541,7 @@ SetVTFont(XtermWidget xw,
 	    USE_CACHED(f_wb, fWBold);
 #endif
 	    if (xtermLoadFont(xw,
-			      &myfonts,
+			      &new_fnames,
 			      doresize, which)) {
 		/*
 		 * If successful, save the data so that a subsequent query via
@@ -3529,10 +3553,8 @@ SetVTFont(XtermWidget xw,
 		SAVE_FNAME(f_w, fWide);
 		SAVE_FNAME(f_wb, fWBold);
 #endif
+		result = TRUE;
 	    } else {
-		xtermLoadFont(xw,
-			      xtermFontName(screen->MenuFontName(oldFont)),
-			      doresize, oldFont);
 		Bell(xw, XkbBI_MinorError, 0);
 	    }
 	    FREE_FNAME(f_n);
@@ -3545,5 +3567,6 @@ SetVTFont(XtermWidget xw,
     } else {
 	Bell(xw, XkbBI_MinorError, 0);
     }
-    return;
+    TRACE(("...SetVTFont: %d\n", result));
+    return result;
 }
Index: xterm-308/fontutils.h
===================================================================
--- xterm-308.orig/fontutils.h
+++ xterm-308/fontutils.h
@@ -37,14 +37,14 @@
 /* *INDENT-OFF* */
 
 extern Bool xtermLoadDefaultFonts (XtermWidget /* xw */);
-extern Bool xtermOpenFont (XtermWidget /* xw */, const char */* name */, XTermFonts * /* result */, fontWarningTypes /* warn */, Bool /* force */);
+extern Bool xtermOpenFont (XtermWidget /* xw */, const char */* name */, XTermFonts * /* result */, fontWarningTypes /* warn */, XTermFonts * /* current */, Bool /* force */);
 extern XTermFonts * xtermCloseFont (XtermWidget /* xw */, XTermFonts * /* fnt */);
 extern const VTFontNames * xtermFontName (const char */* normal */);
 extern int lookupRelativeFontSize (XtermWidget /* xw */, int /* old */, int /* relative */);
 extern int xtermGetFont(const char * /* param */);
-extern int xtermLoadFont (XtermWidget /* xw */, const VTFontNames */* fonts */, Bool /* doresize */, int /* fontnum */);
+extern int xtermLoadFont (XtermWidget /* xw */, const VTFontNames */* fonts */, Bool /* doresizem*/, int /* fontnum */);
 extern void HandleSetFont PROTO_XT_ACTIONS_ARGS;
-extern void SetVTFont (XtermWidget /* xw */, int /* i */, Bool /* doresize */, const VTFontNames */* fonts */);
+extern Bool SetVTFont (XtermWidget /* xw */, int /* i */, Bool /* doresize */, const VTFontNames */* fonts */);
 extern void xtermCloseFonts (XtermWidget /* xw */, XTermFonts * /* fnts[fMAX] */);
 extern void xtermComputeFontInfo (XtermWidget /* xw */, VTwin */* win */, XFontStruct */* font */, int /* sbwidth */);
 extern void xtermCopyFontInfo (XTermFonts * /* target */, XTermFonts * /* source */);
Index: xterm-308/misc.c
===================================================================
--- xterm-308.orig/misc.c
+++ xterm-308/misc.c
@@ -5362,7 +5362,6 @@ xtermSetenv(const char *var, const char
 
 	    found = envindex;
 	    environ[found + 1] = NULL;
-	    environ = environ;
 	}
 
 	environ[found] = CastMallocN(char, 1 + len + strlen(value));
Index: xterm-308/xterm.h
===================================================================
--- xterm-308.orig/xterm.h
+++ xterm-308/xterm.h
@@ -868,7 +868,7 @@ extern void noleaks_cachedCgs (XtermWidg
 extern Bool CheckBufPtrs (TScreen * /* screen */);
 extern Bool set_cursor_gcs (XtermWidget /* xw */);
 extern int VTInit (XtermWidget /* xw */);
-extern void FindFontSelection (XtermWidget /* xw */, const char * /* atom_name */, Bool  /* justprobe */);
+extern Bool FindFontSelection (XtermWidget /* xw */, const char * /* atom_name */, Bool  /* justprobe */);
 extern void HideCursor (void);
 extern void RestartBlinking(TScreen * /* screen */);
 extern void ShowCursor (void);

Places

File xterm-CVE-2022-45063.patch of Package xterm (Revision f41fdf2806690f9bf254baa39955e43e)

Places