Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package MozillaFirefox for openSUSE:Factory checked in at 2022-03-13 20:24:17 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/MozillaFirefox (Old) and /work/SRC/openSUSE:Factory/.MozillaFirefox.new.25692 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "MozillaFirefox" Sun Mar 13 20:24:17 2022 rev:361 rq:960656 version:98.0 Changes: -------- --- /work/SRC/openSUSE:Factory/MozillaFirefox/MozillaFirefox.changes 2022-02-21 17:46:18.819588912 +0100 +++ /work/SRC/openSUSE:Factory/.MozillaFirefox.new.25692/MozillaFirefox.changes 2022-03-13 20:24:18.559594833 +0100 @@ -1,0 +2,27 @@ +Tue Mar 8 10:27:16 UTC 2022 - Wolfgang Rosenauer <w...@rosenauer.org> + +- Mozilla Firefox 98.0 + * Firefox has a new optimized download flow + * other changes as documented here + https://www.mozilla.org/en-US/firefox/98.0/releasenotes + MFSA 2022-10 (bsc#1196900) + * CVE-2022-26383 (bmo#1742421) + Browser window spoof using fullscreen mode + * CVE-2022-26384 (bmo#1744352) + iframe allow-scripts sandbox bypass + * CVE-2022-26387 (bmo#1752979) + Time-of-check time-of-use bug when verifying add-on signatures + * CVE-2022-26381 (bmo#1736243) + Use-after-free in text reflows + * CVE-2022-26382 (bmo#1741888) + Autofill Text could be exfiltrated via side-channel attacks + * CVE-2022-26385 (bmo#1747526) + Use-after-free in thread shutdown + * CVE-2022-0843 (bmo#1746523, bmo#1749062, bmo#1749164, bmo#1749214, + bmo#1749610, bmo#1750032, bmo#1752100, bmo#1752405, bmo#1753612, + bmo#1754508) + Memory safety bugs fixed in Firefox 98 +- requires NSS 3.75 +- add mozilla-bmo1756347.patch to fix i586 build + +------------------------------------------------------------------- @@ -14,0 +42,11 @@ + +------------------------------------------------------------------- +Mon Feb 14 19:31:29 UTC 2022 - Luciano Santos <luc1...@opensuse.org> + +- Remove bashisms ("source" and "function" keywords) from + mozilla.sh.in to ally with the #!/bin/sh shebang. If the end user + has either dash-sh package or busybox-sh to handle Bourn Shell + scripts rather than having bash-sh package, the script would + fail. Using "." instead of "source" and "create_langpack_link()" + function definition is enough to keep both sides sane, + behavior-wise. Old: ---- firefox-97.0.1.source.tar.xz firefox-97.0.1.source.tar.xz.asc l10n-97.0.1.tar.xz New: ---- firefox-98.0.source.tar.xz firefox-98.0.source.tar.xz.asc l10n-98.0.tar.xz mozilla-bmo1756347.patch ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ MozillaFirefox.spec ++++++ --- /var/tmp/diff_new_pack.laI5DQ/_old 2022-03-13 20:24:30.923609347 +0100 +++ /var/tmp/diff_new_pack.laI5DQ/_new 2022-03-13 20:24:30.939609365 +0100 @@ -28,9 +28,9 @@ # orig_suffix b3 # major 69 # mainver %major.99 -%define major 97 -%define mainver %major.0.1 -%define orig_version 97.0.1 +%define major 98 +%define mainver %major.0 +%define orig_version 98.0 %define orig_suffix %{nil} %define update_channel release %define branding 1 @@ -114,7 +114,7 @@ BuildRequires: libproxy-devel BuildRequires: makeinfo BuildRequires: mozilla-nspr-devel >= 4.33 -BuildRequires: mozilla-nss-devel >= 3.74 +BuildRequires: mozilla-nss-devel >= 3.75 BuildRequires: nasm >= 2.14 BuildRequires: nodejs >= 10.22.1 %if 0%{?sle_version} >= 120000 && 0%{?sle_version} < 150000 @@ -219,6 +219,7 @@ Patch21: mozilla-libavcodec58_91.patch Patch22: mozilla-silence-no-return-type.patch Patch23: mozilla-bmo531915.patch +Patch24: mozilla-bmo1756347.patch # Firefox/browser Patch101: firefox-kde.patch Patch102: firefox-branded-icons.patch @@ -685,12 +686,6 @@ %fdupes %{buildroot}%{progdir} %fdupes %{buildroot}%{_datadir} -%clean -rm -rf %{buildroot} -%if %localize -rm -rf %{_tmppath}/translations.* -%endif - %post # update mime and desktop database %mime_database_post ++++++ firefox-97.0.1.source.tar.xz -> firefox-98.0.source.tar.xz ++++++ /work/SRC/openSUSE:Factory/MozillaFirefox/firefox-97.0.1.source.tar.xz /work/SRC/openSUSE:Factory/.MozillaFirefox.new.25692/firefox-98.0.source.tar.xz differ: char 15, line 1 ++++++ l10n-97.0.1.tar.xz -> l10n-98.0.tar.xz ++++++ /work/SRC/openSUSE:Factory/MozillaFirefox/l10n-97.0.1.tar.xz /work/SRC/openSUSE:Factory/.MozillaFirefox.new.25692/l10n-98.0.tar.xz differ: char 26, line 1 ++++++ mozilla-bmo1756347.patch ++++++ # HG changeset patch # User Wolfgang Rosenauer <w...@rosenauer.org> # Parent f805a250257be9c3ea570b34557150450e16dfec diff --git a/js/src/jit/GenerateAtomicOperations.py b/js/src/jit/GenerateAtomicOperations.py --- a/js/src/jit/GenerateAtomicOperations.py +++ b/js/src/jit/GenerateAtomicOperations.py @@ -5,40 +5,41 @@ # This script generates jit/AtomicOperationsGenerated.h # # See the big comment in jit/AtomicOperations.h for an explanation. import buildconfig is_64bit = "JS_64BIT" in buildconfig.defines cpu_arch = buildconfig.substs["CPU_ARCH"] +is_gcc = buildconfig.substs["CC_TYPE"] == "gcc" def fmt_insn(s): return '"' + s + '\\n\\t"\n' def gen_seqcst(fun_name): if cpu_arch in ("x86", "x86_64"): return r""" - inline void %(fun_name)s() { + INLINE_ATTR void %(fun_name)s() { asm volatile ("mfence\n\t" ::: "memory"); }""" % { "fun_name": fun_name, } if cpu_arch == "aarch64": return r""" - inline void %(fun_name)s() { + INLINE_ATTR void %(fun_name)s() { asm volatile ("dmb ish\n\t" ::: "memory"); }""" % { "fun_name": fun_name, } if cpu_arch == "arm": return r""" - inline void %(fun_name)s() { + INLINE_ATTR void %(fun_name)s() { asm volatile ("dmb sy\n\t" ::: "memory"); }""" % { "fun_name": fun_name, } raise Exception("Unexpected arch") def gen_load(fun_name, cpp_type, size, barrier): @@ -58,17 +59,17 @@ def gen_load(fun_name, cpp_type, size, b elif size == 32: insns += fmt_insn("movl (%[arg]), %[res]") else: assert size == 64 insns += fmt_insn("movq (%[arg]), %[res]") if barrier: insns += fmt_insn("mfence") return """ - inline %(cpp_type)s %(fun_name)s(const %(cpp_type)s* arg) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(const %(cpp_type)s* arg) { %(cpp_type)s res; asm volatile (%(insns)s : [res] "=r" (res) : [arg] "r" (arg) : "memory"); return res; }""" % { "cpp_type": cpp_type, @@ -86,17 +87,17 @@ def gen_load(fun_name, cpp_type, size, b elif size == 32: insns += fmt_insn("ldr %w[res], [%x[arg]]") else: assert size == 64 insns += fmt_insn("ldr %x[res], [%x[arg]]") if barrier: insns += fmt_insn("dmb ish") return """ - inline %(cpp_type)s %(fun_name)s(const %(cpp_type)s* arg) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(const %(cpp_type)s* arg) { %(cpp_type)s res; asm volatile (%(insns)s : [res] "=r" (res) : [arg] "r" (arg) : "memory"); return res; }""" % { "cpp_type": cpp_type, @@ -112,17 +113,17 @@ def gen_load(fun_name, cpp_type, size, b elif size == 16: insns += fmt_insn("ldrh %[res], [%[arg]]") else: assert size == 32 insns += fmt_insn("ldr %[res], [%[arg]]") if barrier: insns += fmt_insn("dmb sy") return """ - inline %(cpp_type)s %(fun_name)s(const %(cpp_type)s* arg) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(const %(cpp_type)s* arg) { %(cpp_type)s res; asm volatile (%(insns)s : [res] "=r" (res) : [arg] "r" (arg) : "memory"); return res; }""" % { "cpp_type": cpp_type, @@ -149,17 +150,17 @@ def gen_store(fun_name, cpp_type, size, elif size == 32: insns += fmt_insn("movl %[val], (%[addr])") else: assert size == 64 insns += fmt_insn("movq %[val], (%[addr])") if barrier: insns += fmt_insn("mfence") return """ - inline void %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR void %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { asm volatile (%(insns)s : : [addr] "r" (addr), [val] "r"(val) : "memory"); }""" % { "cpp_type": cpp_type, "fun_name": fun_name, "insns": insns, @@ -175,17 +176,17 @@ def gen_store(fun_name, cpp_type, size, elif size == 32: insns += fmt_insn("str %w[val], [%x[addr]]") else: assert size == 64 insns += fmt_insn("str %x[val], [%x[addr]]") if barrier: insns += fmt_insn("dmb ish") return """ - inline void %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR void %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { asm volatile (%(insns)s : : [addr] "r" (addr), [val] "r"(val) : "memory"); }""" % { "cpp_type": cpp_type, "fun_name": fun_name, "insns": insns, @@ -199,17 +200,17 @@ def gen_store(fun_name, cpp_type, size, elif size == 16: insns += fmt_insn("strh %[val], [%[addr]]") else: assert size == 32 insns += fmt_insn("str %[val], [%[addr]]") if barrier: insns += fmt_insn("dmb sy") return """ - inline void %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR void %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { asm volatile (%(insns)s : : [addr] "r" (addr), [val] "r"(val) : "memory"); }""" % { "cpp_type": cpp_type, "fun_name": fun_name, "insns": insns, @@ -230,17 +231,17 @@ def gen_exchange(fun_name, cpp_type, siz elif size == 16: insns += fmt_insn("xchgw %[val], (%[addr])") elif size == 32: insns += fmt_insn("xchgl %[val], (%[addr])") else: assert size == 64 insns += fmt_insn("xchgq %[val], (%[addr])") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { asm volatile (%(insns)s : [val] "+r" (val) : [addr] "r" (addr) : "memory"); return val; }""" % { "cpp_type": cpp_type, "fun_name": fun_name, @@ -261,17 +262,17 @@ def gen_exchange(fun_name, cpp_type, siz insns += fmt_insn("stxr %w[scratch], %w[val], [%x[addr]]") else: assert size == 64 insns += fmt_insn("ldxr %x[res], [%x[addr]]") insns += fmt_insn("stxr %w[scratch], %x[val], [%x[addr]]") insns += fmt_insn("cbnz %w[scratch], 0b") insns += fmt_insn("dmb ish") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { %(cpp_type)s res; uint32_t scratch; asm volatile (%(insns)s : [res] "=&r"(res), [scratch] "=&r"(scratch) : [addr] "r" (addr), [val] "r"(val) : "memory", "cc"); return res; }""" % { @@ -292,17 +293,17 @@ def gen_exchange(fun_name, cpp_type, siz else: assert size == 32 insns += fmt_insn("ldrex %[res], [%[addr]]") insns += fmt_insn("strex %[scratch], %[val], [%[addr]]") insns += fmt_insn("cmp %[scratch], #1") insns += fmt_insn("beq 0b") insns += fmt_insn("dmb sy") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { %(cpp_type)s res; uint32_t scratch; asm volatile (%(insns)s : [res] "=&r"(res), [scratch] "=&r"(scratch) : [addr] "r" (addr), [val] "r"(val) : "memory", "cc"); return res; }""" % { @@ -316,33 +317,33 @@ def gen_exchange(fun_name, cpp_type, siz def gen_cmpxchg(fun_name, cpp_type, size): # NOTE: the assembly code must match the generated code in: # - MacroAssembler::compareExchange # - MacroAssembler::compareExchange64 if cpu_arch == "x86" and size == 64: # Use a +A constraint to load `oldval` into EDX:EAX as input/output. # `newval` is loaded into ECX:EBX. return r""" - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s oldval, %(cpp_type)s newval) { asm volatile ("lock; cmpxchg8b (%%[addr])\n\t" : "+A" (oldval) : [addr] "r" (addr), "b" (uint32_t(newval & 0xffff'ffff)), "c" (uint32_t(newval >> 32)) : "memory", "cc"); return oldval; }""" % { "cpp_type": cpp_type, "fun_name": fun_name, } if cpu_arch == "arm" and size == 64: return r""" - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s oldval, %(cpp_type)s newval) { uint32_t oldval0 = oldval & 0xffff'ffff; uint32_t oldval1 = oldval >> 32; uint32_t newval0 = newval & 0xffff'ffff; uint32_t newval1 = newval >> 32; asm volatile ( "dmb sy\n\t" @@ -375,17 +376,17 @@ def gen_cmpxchg(fun_name, cpp_type, size elif size == 16: insns += fmt_insn("lock; cmpxchgw %[newval], (%[addr])") elif size == 32: insns += fmt_insn("lock; cmpxchgl %[newval], (%[addr])") else: assert size == 64 insns += fmt_insn("lock; cmpxchgq %[newval], (%[addr])") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s oldval, %(cpp_type)s newval) { asm volatile (%(insns)s : [oldval] "+a" (oldval) : [addr] "r" (addr), [newval] "r" (newval) : "memory", "cc"); return oldval; }""" % { @@ -420,17 +421,17 @@ def gen_cmpxchg(fun_name, cpp_type, size insns += fmt_insn("mov %x[scratch], %x[oldval]") insns += fmt_insn("ldxr %x[res], [%x[addr]]") insns += fmt_insn("cmp %x[res], %x[scratch]") insns += fmt_insn("b.ne 1f") insns += fmt_insn("stxr %w[scratch], %x[newval], [%x[addr]]") insns += fmt_insn("cbnz %w[scratch], 0b") insns += fmt_insn("1: dmb ish") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s oldval, %(cpp_type)s newval) { %(cpp_type)s res, scratch; asm volatile (%(insns)s : [res] "=&r" (res), [scratch] "=&r" (scratch) : [addr] "r" (addr), [oldval] "r"(oldval), [newval] "r" (newval) : "memory", "cc"); return res; @@ -461,17 +462,17 @@ def gen_cmpxchg(fun_name, cpp_type, size insns += fmt_insn("ldrex %[res], [%[addr]]") insns += fmt_insn("cmp %[res], %[scratch]") insns += fmt_insn("bne 1f") insns += fmt_insn("strex %[scratch], %[newval], [%[addr]]") insns += fmt_insn("cmp %[scratch], #1") insns += fmt_insn("beq 0b") insns += fmt_insn("1: dmb sy") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s oldval, %(cpp_type)s newval) { %(cpp_type)s res, scratch; asm volatile (%(insns)s : [res] "=&r" (res), [scratch] "=&r" (scratch) : [addr] "r" (addr), [oldval] "r"(oldval), [newval] "r" (newval) : "memory", "cc"); return res; @@ -496,17 +497,17 @@ def gen_fetchop(fun_name, cpp_type, size elif size == 16: insns += fmt_insn("lock; xaddw %[val], (%[addr])") elif size == 32: insns += fmt_insn("lock; xaddl %[val], (%[addr])") else: assert size == 64 insns += fmt_insn("lock; xaddq %[val], (%[addr])") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { asm volatile (%(insns)s : [val] "+&r" (val) : [addr] "r" (addr) : "memory", "cc"); return val; }""" % { "cpp_type": cpp_type, "fun_name": fun_name, @@ -534,17 +535,17 @@ def gen_fetchop(fun_name, cpp_type, size assert size == 64 insns += fmt_insn("movq (%[addr]), %[res]") insns += fmt_insn("0: movq %[res], %[scratch]") insns += fmt_insn("OPq %[val], %[scratch]") insns += fmt_insn("lock; cmpxchgq %[scratch], (%[addr])") insns = insns.replace("OP", op) insns += fmt_insn("jnz 0b") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { %(cpp_type)s res, scratch; asm volatile (%(insns)s : [res] "=&a" (res), [scratch] "=&r" (scratch) : [addr] "r" (addr), [val] "r"(val) : "memory", "cc"); return res; }""" % { "cpp_type": cpp_type, @@ -576,17 +577,17 @@ def gen_fetchop(fun_name, cpp_type, size if cpu_op == "or": cpu_op = "orr" if cpu_op == "xor": cpu_op = "eor" insns = insns.replace("OP", cpu_op) insns += fmt_insn("cbnz %w[scratch2], 0b") insns += fmt_insn("dmb ish") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { %(cpp_type)s res; uintptr_t scratch1, scratch2; asm volatile (%(insns)s : [res] "=&r" (res), [scratch1] "=&r" (scratch1), [scratch2] "=&r"(scratch2) : [addr] "r" (addr), [val] "r"(val) : "memory", "cc"); return res; }""" % { @@ -616,17 +617,17 @@ def gen_fetchop(fun_name, cpp_type, size cpu_op = "orr" if cpu_op == "xor": cpu_op = "eor" insns = insns.replace("OP", cpu_op) insns += fmt_insn("cmp %[scratch2], #1") insns += fmt_insn("beq 0b") insns += fmt_insn("dmb sy") return """ - inline %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { + INLINE_ATTR %(cpp_type)s %(fun_name)s(%(cpp_type)s* addr, %(cpp_type)s val) { %(cpp_type)s res; uintptr_t scratch1, scratch2; asm volatile (%(insns)s : [res] "=&r" (res), [scratch1] "=&r" (scratch1), [scratch2] "=&r"(scratch2) : [addr] "r" (addr), [val] "r"(val) : "memory", "cc"); return res; }""" % { @@ -660,33 +661,33 @@ def gen_copy(fun_name, cpp_type, size, u insns += fmt_insn("ldrb %w[scratch], [%x[src], OFFSET]") insns += fmt_insn("strb %w[scratch], [%x[dst], OFFSET]") else: assert size == 8 insns += fmt_insn("ldr %x[scratch], [%x[src], OFFSET]") insns += fmt_insn("str %x[scratch], [%x[dst], OFFSET]") elif cpu_arch == "arm": if size == 1: - insns += fmt_insn("ldrb %[scratch], [%[src], OFFSET]") - insns += fmt_insn("strb %[scratch], [%[dst], OFFSET]") + insns += fmt_insn("ldrb %[scratch], [%[src], #OFFSET]") + insns += fmt_insn("strb %[scratch], [%[dst], #OFFSET]") else: assert size == 4 - insns += fmt_insn("ldr %[scratch], [%[src], OFFSET]") - insns += fmt_insn("str %[scratch], [%[dst], OFFSET]") + insns += fmt_insn("ldr %[scratch], [%[src], #OFFSET]") + insns += fmt_insn("str %[scratch], [%[dst], #OFFSET]") else: raise Exception("Unexpected arch") insns = insns.replace("OFFSET", str(offset * size)) if direction == "down": offset += 1 else: offset -= 1 return """ - inline void %(fun_name)s(uint8_t* dst, const uint8_t* src) { + INLINE_ATTR void %(fun_name)s(uint8_t* dst, const uint8_t* src) { %(cpp_type)s* dst_ = reinterpret_cast<%(cpp_type)s*>(dst); const %(cpp_type)s* src_ = reinterpret_cast<const %(cpp_type)s*>(src); %(cpp_type)s scratch; asm volatile (%(insns)s : [scratch] "=&r" (scratch) : [dst] "r" (dst_), [src] "r"(src_) : "memory"); }""" % { @@ -848,14 +849,21 @@ def generate_atomics_header(c_out): "constexpr size_t JS_GENERATED_ATOMICS_BLOCKSIZE = " + str(blocksize) + ";\n" ) contents += ( "constexpr size_t JS_GENERATED_ATOMICS_WORDSIZE = " + str(wordsize) + ";\n" ) + # Work around a GCC issue on 32-bit x86 by adding MOZ_NEVER_INLINE. + # See bug 1756347. + if is_gcc and cpu_arch == "x86": + contents = contents.replace("INLINE_ATTR", "MOZ_NEVER_INLINE inline") + else: + contents = contents.replace("INLINE_ATTR", "inline") + c_out.write( HEADER_TEMPLATE % { "contents": contents, } ) ++++++ mozilla-silence-no-return-type.patch ++++++ --- /var/tmp/diff_new_pack.laI5DQ/_old 2022-03-13 20:24:31.299609790 +0100 +++ /var/tmp/diff_new_pack.laI5DQ/_new 2022-03-13 20:24:31.303609794 +0100 @@ -1,10 +1,10 @@ # HG changeset patch -# Parent 216843712d6d6cd9d5bd519f6ef564d00406b43f +# Parent 1191efd2ea64c4081a1825176a50e872a525d4da diff --git a/Cargo.lock b/Cargo.lock --- a/Cargo.lock +++ b/Cargo.lock -@@ -2165,18 +2165,16 @@ name = "glsl-to-cxx" +@@ -2196,18 +2196,16 @@ name = "glsl-to-cxx" version = "0.1.0" dependencies = [ "glsl", @@ -26,8 +26,8 @@ diff --git a/Cargo.toml b/Cargo.toml --- a/Cargo.toml +++ b/Cargo.toml -@@ -102,13 +102,13 @@ moz_asserts = { path = "mozglue/static/r - # Other overrides +@@ -106,13 +106,13 @@ moz_asserts = { path = "mozglue/static/r + async-task = { git = "https://github.com/smol-rs/async-task";, rev="f6488e35beccb26eb6e85847b02aa78a42cd3d0e" } chardetng = { git = "https://github.com/hsivonen/chardetng";, rev="3484d3e3ebdc8931493aa5df4d7ee9360a90e76b" } chardetng_c = { git = "https://github.com/hsivonen/chardetng_c";, rev="ed8a4c6f900a90d4dbc1d64b856e61490a1c3570" } coremidi = { git = "https://github.com/chris-zen/coremidi.git";, rev="fc68464b5445caf111e41f643a2e69ccce0b4f83" } ++++++ mozilla.sh.in ++++++ --- /var/tmp/diff_new_pack.laI5DQ/_old 2022-03-13 20:24:31.339609836 +0100 +++ /var/tmp/diff_new_pack.laI5DQ/_new 2022-03-13 20:24:31.343609841 +0100 @@ -100,7 +100,7 @@ fi # xinput2 (boo#1173320) -source /etc/os-release +. /etc/os-release if [ "$ID" = "opensuse-tumbleweed" ]; then export MOZ_USE_XINPUT2=1 fi @@ -151,7 +151,7 @@ # Try with a local variant first, then without a local variant SHORTMOZLOCALE=`echo $CURRENT_LOCALE | sed "s|_\([^.]*\).*||g" | sed "s|\..*||g"` MOZLOCALE=`echo $CURRENT_LOCALE | sed "s|_\([^.]*\).*|-\1|g" | sed "s|\..*||g"` - function create_langpack_link() { + create_langpack_link() { local language=$* local langpack=langpack-${language}@firefox.mozilla.org.xpi if [ -f $MOZ_LANGPACKS_DIR/$langpack ]; then ++++++ tar_stamps ++++++ --- /var/tmp/diff_new_pack.laI5DQ/_old 2022-03-13 20:24:31.379609883 +0100 +++ /var/tmp/diff_new_pack.laI5DQ/_new 2022-03-13 20:24:31.383609888 +0100 @@ -1,11 +1,11 @@ PRODUCT="firefox" CHANNEL="release" -VERSION="97.0.1" +VERSION="98.0" VERSION_SUFFIX="" -PREV_VERSION="97.0" +PREV_VERSION="97.0.1" PREV_VERSION_SUFFIX="" #SKIP_LOCALES="" # Uncomment to skip l10n and compare-locales-generation RELEASE_REPO="https://hg.mozilla.org/releases/mozilla-release"; -RELEASE_TAG="0f0ba6e8029d8148743c4aa50c2be4c4c643f8a4" -RELEASE_TIMESTAMP="20220216172458" +RELEASE_TAG="829802cfd689497a5e8fd978bbb3099245bd131c" +RELEASE_TIMESTAMP="20220304153049"
