diff --git a/0001-add-secure-compile-option.patch b/0001-add-secure-compile-option.patch new file mode 100644 index 0000000000000000000000000000000000000000..0594f0eb266786cb518faf323a62c73a83e2658e --- /dev/null +++ b/0001-add-secure-compile-option.patch @@ -0,0 +1,27 @@ +From 4cf6dc9f628fc2c5b3478d70e15d4fab8a32ae86 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Wed, 10 Apr 2024 11:43:51 +0800 +Subject: [PATCH] add secure compile option + +Signed-off-by: zhongtao +--- + CMakeLists.txt | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 4137ce2..d17f09d 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -2,6 +2,9 @@ + # to 3.26. + cmake_minimum_required(VERSION 3.10...3.26) + ++set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,now -fstack-check -fPIE") ++set(CMAKE_EXE_LINKER_FLAGS "-pie") ++ + # Revert to old behavior for MSVC debug symbols. + if(POLICY CMP0141) + cmake_policy(SET CMP0141 OLD) +-- +2.25.1 + diff --git a/0002-Fix-CC-compiler-support.patch b/0002-Fix-CC-compiler-support.patch new file mode 100644 index 0000000000000000000000000000000000000000..d4f444075ef1c4e086a696cd2fd38f923e616854 --- /dev/null +++ b/0002-Fix-CC-compiler-support.patch @@ -0,0 +1,29 @@ +From b62fbe3852ea070f1bfbb048e71dfae70c7c71f0 Mon Sep 17 00:00:00 2001 +From: wangqiang +Date: Tue, 19 Mar 2024 18:54:13 +0800 +Subject: [PATCH] Fix CC compiler support + +--- + third_party/utf8_range/utf8_to_utf16/Makefile | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/third_party/utf8_range/utf8_to_utf16/Makefile b/third_party/utf8_range/utf8_to_utf16/Makefile +index 853ffa4..30ef021 100644 +--- a/third_party/utf8_range/utf8_to_utf16/Makefile ++++ b/third_party/utf8_range/utf8_to_utf16/Makefile +@@ -1,10 +1,10 @@ +-CC = gcc ++CC := ${CC} + CPPFLAGS = -g -O3 -Wall -march=native + + OBJS = main.o iconv.o naive.o + + utf8to16: ${OBJS} +- gcc $^ -o $@ ++ ${CC} $^ -o $@ + + .PHONY: clean + clean: +-- +2.33.0 + diff --git a/0003-protobuf-add-coverage-compile-option.patch b/0003-protobuf-add-coverage-compile-option.patch new file mode 100644 index 0000000000000000000000000000000000000000..7a6aa174a084709d54f012ed447d4ebabbe559e7 --- /dev/null +++ b/0003-protobuf-add-coverage-compile-option.patch @@ -0,0 +1,27 @@ +From ea6d56c3518dc3af0f326f52a266bc0986d8635c Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Thu, 25 Jul 2024 21:42:22 +0800 +Subject: [PATCH] protobuf: add coverage compile option + +Signed-off-by: zhongtao +--- + CMakeLists.txt | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index d17f09d..0b169f3 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -4,6 +4,9 @@ cmake_minimum_required(VERSION 3.10...3.26) + + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,now -fstack-check -fPIE") + set(CMAKE_EXE_LINKER_FLAGS "-pie") ++if (ENABLE_CONVERAGE) ++ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage") ++endif() + + # Revert to old behavior for MSVC debug symbols. + if(POLICY CMP0141) +-- +2.25.1 + diff --git a/0004-backport-CVE-2024-7254-1.patch b/0004-backport-CVE-2024-7254-1.patch new file mode 100644 index 0000000000000000000000000000000000000000..89492db67fc0980eb01f9abefe46547904e3fed5 --- /dev/null +++ b/0004-backport-CVE-2024-7254-1.patch @@ -0,0 +1,146 @@ +From cc8b3483a5584b3301e3d43d17eb59704857ffaa Mon Sep 17 00:00:00 2001 +From: Protobuf Team Bot +Date: Thu, 18 Jul 2024 07:41:01 -0700 +Subject: [PATCH] Internal change + +PiperOrigin-RevId: 653615736 +--- + .../core/src/main/java/com/google/protobuf/ArrayDecoders.java | 3 +-- + .../com/google/protobuf/InvalidProtocolBufferException.java | 2 +- + .../core/src/main/java/com/google/protobuf/MessageSchema.java | 3 +++ + .../src/main/java/com/google/protobuf/MessageSetSchema.java | 1 + + .../src/main/java/com/google/protobuf/UnknownFieldSchema.java | 3 +-- + java/lite/src/test/java/com/google/protobuf/LiteTest.java | 3 +++ + src/google/protobuf/unittest_lite.proto | 4 ++++ + 7 files changed, 14 insertions(+), 5 deletions(-) + +diff --git a/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java +index f3241de..9bf1439 100644 +--- a/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java ++++ b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java +@@ -24,8 +24,7 @@ import java.io.IOException; + @CheckReturnValue + final class ArrayDecoders { + +- private ArrayDecoders() { +- } ++ private ArrayDecoders() {} + + /** + * A helper used to return multiple values in a Java function. Java doesn't natively support +diff --git a/java/core/src/main/java/com/google/protobuf/InvalidProtocolBufferException.java b/java/core/src/main/java/com/google/protobuf/InvalidProtocolBufferException.java +index 5d10e48..dbcb9e8 100644 +--- a/java/core/src/main/java/com/google/protobuf/InvalidProtocolBufferException.java ++++ b/java/core/src/main/java/com/google/protobuf/InvalidProtocolBufferException.java +@@ -132,7 +132,7 @@ public class InvalidProtocolBufferException extends IOException { + static InvalidProtocolBufferException recursionLimitExceeded() { + return new InvalidProtocolBufferException( + "Protocol message had too many levels of nesting. May be malicious. " +- + "Use CodedInputStream.setRecursionLimit() to increase the depth limit."); ++ + "Use setRecursionLimit() to increase the recursion depth limit."); + } + + static InvalidProtocolBufferException sizeLimitExceeded() { +diff --git a/java/core/src/main/java/com/google/protobuf/MessageSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSchema.java +index de3890f..f8f79fc 100644 +--- a/java/core/src/main/java/com/google/protobuf/MessageSchema.java ++++ b/java/core/src/main/java/com/google/protobuf/MessageSchema.java +@@ -3006,6 +3006,7 @@ final class MessageSchema implements Schema { + unknownFields = unknownFieldSchema.getBuilderFromMessage(message); + } + // Unknown field. ++ + if (unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) { + continue; + } +@@ -3381,6 +3382,7 @@ final class MessageSchema implements Schema { + if (unknownFields == null) { + unknownFields = unknownFieldSchema.getBuilderFromMessage(message); + } ++ + if (!unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) { + return; + } +@@ -3397,6 +3399,7 @@ final class MessageSchema implements Schema { + if (unknownFields == null) { + unknownFields = unknownFieldSchema.getBuilderFromMessage(message); + } ++ + if (!unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) { + return; + } +diff --git a/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java +index eec3acd..a17037e 100644 +--- a/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java ++++ b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java +@@ -278,6 +278,7 @@ final class MessageSetSchema implements Schema { + reader, extension, extensionRegistry, extensions); + return true; + } else { ++ + return unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader); + } + } else { +diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java +index c4ec645..a43bc2a 100644 +--- a/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java ++++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java +@@ -55,7 +55,6 @@ abstract class UnknownFieldSchema { + /** Marks unknown fields as immutable. */ + abstract void makeImmutable(Object message); + +- /** Merges one field into the unknown fields. */ + final boolean mergeOneFieldFrom(B unknownFields, Reader reader) throws IOException { + int tag = reader.getTag(); + int fieldNumber = WireFormat.getTagFieldNumber(tag); +@@ -88,7 +87,7 @@ abstract class UnknownFieldSchema { + } + } + +- final void mergeFrom(B unknownFields, Reader reader) throws IOException { ++ private final void mergeFrom(B unknownFields, Reader reader) throws IOException { + while (true) { + if (reader.getFieldNumber() == Reader.READ_DONE + || !mergeOneFieldFrom(unknownFields, reader)) { +diff --git a/java/lite/src/test/java/com/google/protobuf/LiteTest.java b/java/lite/src/test/java/com/google/protobuf/LiteTest.java +index 754ed7d..b42a4b9 100644 +--- a/java/lite/src/test/java/com/google/protobuf/LiteTest.java ++++ b/java/lite/src/test/java/com/google/protobuf/LiteTest.java +@@ -10,12 +10,14 @@ package com.google.protobuf; + import static com.google.common.truth.Truth.assertThat; + import static com.google.common.truth.Truth.assertWithMessage; + import static java.util.Collections.singletonList; ++import static org.junit.Assert.assertThrows; + + import com.google.protobuf.FieldPresenceTestProto.TestAllTypes; + import com.google.protobuf.UnittestImportLite.ImportEnumLite; + import com.google.protobuf.UnittestImportPublicLite.PublicImportMessageLite; + import com.google.protobuf.UnittestLite.ForeignEnumLite; + import com.google.protobuf.UnittestLite.ForeignMessageLite; ++import com.google.protobuf.UnittestLite.RecursiveGroup; + import com.google.protobuf.UnittestLite.RecursiveMessage; + import com.google.protobuf.UnittestLite.TestAllExtensionsLite; + import com.google.protobuf.UnittestLite.TestAllTypesLite; +@@ -50,6 +52,7 @@ import java.util.ArrayList; + import java.util.Arrays; + import java.util.Iterator; + import java.util.List; ++import java.util.concurrent.atomic.AtomicBoolean; + import org.junit.Before; + import org.junit.Test; + import org.junit.runner.RunWith; +diff --git a/src/google/protobuf/unittest_lite.proto b/src/google/protobuf/unittest_lite.proto +index 1848a2a..af6febf 100644 +--- a/src/google/protobuf/unittest_lite.proto ++++ b/src/google/protobuf/unittest_lite.proto +@@ -505,3 +505,7 @@ message RecursiveMessage { + optional RecursiveMessage recurse = 1; + optional bytes payload = 2; + } ++ ++message RecursiveGroup { ++ RecursiveGroup recurse = 1 [features.message_encoding = DELIMITED]; ++} +-- +2.43.0 + diff --git a/0004-backport-CVE-2024-7254-2.patch b/0004-backport-CVE-2024-7254-2.patch new file mode 100644 index 0000000000000000000000000000000000000000..f7072790c731f9e1b19a0c0d99be6f4eeb3dc672 --- /dev/null +++ b/0004-backport-CVE-2024-7254-2.patch @@ -0,0 +1,696 @@ +From 4728531c162f2f9e8c2ca1add713cfee2db6be3b Mon Sep 17 00:00:00 2001 +From: Protobuf Team Bot +Date: Tue, 17 Sep 2024 12:03:36 -0700 +Subject: [PATCH] Add recursion check when parsing unknown fields in Java. + +PiperOrigin-RevId: 675657198 +--- + .../com/google/protobuf/ArrayDecoders.java | 28 +++ + .../com/google/protobuf/CodedInputStream.java | 18 +- + .../com/google/protobuf/MessageSchema.java | 12 +- + .../com/google/protobuf/MessageSetSchema.java | 3 +- + .../google/protobuf/UnknownFieldSchema.java | 29 ++- + .../google/protobuf/CodedInputStreamTest.java | 158 ++++++++++++ + .../java/com/google/protobuf/LiteTest.java | 232 ++++++++++++++++++ + 7 files changed, 466 insertions(+), 14 deletions(-) + +diff --git a/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java +index 9bf1439..bf5f922 100644 +--- a/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java ++++ b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java +@@ -23,6 +23,10 @@ import java.io.IOException; + */ + @CheckReturnValue + final class ArrayDecoders { ++ static final int DEFAULT_RECURSION_LIMIT = 100; ++ ++ @SuppressWarnings("NonFinalStaticField") ++ private static volatile int recursionLimit = DEFAULT_RECURSION_LIMIT; + + private ArrayDecoders() {} + +@@ -37,6 +41,7 @@ final class ArrayDecoders { + public long long1; + public Object object1; + public final ExtensionRegistryLite extensionRegistry; ++ public int recursionDepth; + + Registers() { + this.extensionRegistry = ExtensionRegistryLite.getEmptyRegistry(); +@@ -244,7 +249,10 @@ final class ArrayDecoders { + if (length < 0 || length > limit - position) { + throw InvalidProtocolBufferException.truncatedMessage(); + } ++ registers.recursionDepth++; ++ checkRecursionLimit(registers.recursionDepth); + schema.mergeFrom(msg, data, position, position + length, registers); ++ registers.recursionDepth--; + registers.object1 = msg; + return position + length; + } +@@ -262,8 +270,11 @@ final class ArrayDecoders { + // A group field must has a MessageSchema (the only other subclass of Schema is MessageSetSchema + // and it can't be used in group fields). + final MessageSchema messageSchema = (MessageSchema) schema; ++ registers.recursionDepth++; ++ checkRecursionLimit(registers.recursionDepth); + final int endPosition = + messageSchema.parseMessage(msg, data, position, limit, endGroup, registers); ++ registers.recursionDepth--; + registers.object1 = msg; + return endPosition; + } +@@ -1024,6 +1035,8 @@ final class ArrayDecoders { + final UnknownFieldSetLite child = UnknownFieldSetLite.newInstance(); + final int endGroup = (tag & ~0x7) | WireFormat.WIRETYPE_END_GROUP; + int lastTag = 0; ++ registers.recursionDepth++; ++ checkRecursionLimit(registers.recursionDepth); + while (position < limit) { + position = decodeVarint32(data, position, registers); + lastTag = registers.int1; +@@ -1032,6 +1045,7 @@ final class ArrayDecoders { + } + position = decodeUnknownField(lastTag, data, position, limit, child, registers); + } ++ registers.recursionDepth--; + if (position > limit || lastTag != endGroup) { + throw InvalidProtocolBufferException.parseFailure(); + } +@@ -1078,4 +1092,18 @@ final class ArrayDecoders { + throw InvalidProtocolBufferException.invalidTag(); + } + } ++ ++ /** ++ * Set the maximum recursion limit that ArrayDecoders will allow. An exception will be thrown if ++ * the depth of the message exceeds this limit. ++ */ ++ public static void setRecursionLimit(int limit) { ++ recursionLimit = limit; ++ } ++ ++ private static void checkRecursionLimit(int depth) throws InvalidProtocolBufferException { ++ if (depth >= recursionLimit) { ++ throw InvalidProtocolBufferException.recursionLimitExceeded(); ++ } ++ } + } +diff --git a/java/core/src/main/java/com/google/protobuf/CodedInputStream.java b/java/core/src/main/java/com/google/protobuf/CodedInputStream.java +index 8f1ac73..f8df4d3 100644 +--- a/java/core/src/main/java/com/google/protobuf/CodedInputStream.java ++++ b/java/core/src/main/java/com/google/protobuf/CodedInputStream.java +@@ -2180,7 +2180,14 @@ public abstract class CodedInputStream { + public void skipMessage() throws IOException { + while (true) { + final int tag = readTag(); +- if (tag == 0 || !skipField(tag)) { ++ if (tag == 0 ) { ++ return; ++ } ++ checkRecursionLimit(); ++ ++recursionDepth; ++ boolean fieldSkipped = skipField(tag); ++ --recursionDepth; ++ if (!fieldSkipped) { + return; + } + } +@@ -2190,9 +2197,16 @@ public abstract class CodedInputStream { + public void skipMessage(CodedOutputStream output) throws IOException { + while (true) { + final int tag = readTag(); +- if (tag == 0 || !skipField(tag, output)) { ++ if (tag == 0) { + return; + } ++ checkRecursionLimit(); ++ ++recursionDepth; ++ boolean fieldSkipped = skipField(tag, output); ++ --recursionDepth; ++ if (!fieldSkipped) { ++ return; ++ } + } + } + +diff --git a/java/core/src/main/java/com/google/protobuf/MessageSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSchema.java +index f8f79fc..5ad6762 100644 +--- a/java/core/src/main/java/com/google/protobuf/MessageSchema.java ++++ b/java/core/src/main/java/com/google/protobuf/MessageSchema.java +@@ -3006,8 +3006,8 @@ final class MessageSchema implements Schema { + unknownFields = unknownFieldSchema.getBuilderFromMessage(message); + } + // Unknown field. +- +- if (unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) { ++ if (unknownFieldSchema.mergeOneFieldFrom( ++ unknownFields, reader, /* currentDepth= */ 0)) { + continue; + } + } +@@ -3382,8 +3382,8 @@ final class MessageSchema implements Schema { + if (unknownFields == null) { + unknownFields = unknownFieldSchema.getBuilderFromMessage(message); + } +- +- if (!unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) { ++ if (!unknownFieldSchema.mergeOneFieldFrom( ++ unknownFields, reader, /* currentDepth= */ 0)) { + return; + } + break; +@@ -3399,8 +3399,8 @@ final class MessageSchema implements Schema { + if (unknownFields == null) { + unknownFields = unknownFieldSchema.getBuilderFromMessage(message); + } +- +- if (!unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) { ++ if (!unknownFieldSchema.mergeOneFieldFrom( ++ unknownFields, reader, /* currentDepth= */ 0)) { + return; + } + } +diff --git a/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java +index a17037e..ec37d41 100644 +--- a/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java ++++ b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java +@@ -278,8 +278,7 @@ final class MessageSetSchema implements Schema { + reader, extension, extensionRegistry, extensions); + return true; + } else { +- +- return unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader); ++ return unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader, /* currentDepth= */ 0); + } + } else { + return reader.skipField(); +diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java +index a43bc2a..80602b1 100644 +--- a/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java ++++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSchema.java +@@ -13,6 +13,11 @@ import java.io.IOException; + @CheckReturnValue + abstract class UnknownFieldSchema { + ++ static final int DEFAULT_RECURSION_LIMIT = 100; ++ ++ @SuppressWarnings("NonFinalStaticField") ++ private static volatile int recursionLimit = DEFAULT_RECURSION_LIMIT; ++ + /** Whether unknown fields should be dropped. */ + abstract boolean shouldDiscardUnknownFields(Reader reader); + +@@ -55,7 +60,9 @@ abstract class UnknownFieldSchema { + /** Marks unknown fields as immutable. */ + abstract void makeImmutable(Object message); + +- final boolean mergeOneFieldFrom(B unknownFields, Reader reader) throws IOException { ++ /** Merges one field into the unknown fields. */ ++ final boolean mergeOneFieldFrom(B unknownFields, Reader reader, int currentDepth) ++ throws IOException { + int tag = reader.getTag(); + int fieldNumber = WireFormat.getTagFieldNumber(tag); + switch (WireFormat.getTagWireType(tag)) { +@@ -74,7 +81,12 @@ abstract class UnknownFieldSchema { + case WireFormat.WIRETYPE_START_GROUP: + final B subFields = newBuilder(); + int endGroupTag = WireFormat.makeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP); +- mergeFrom(subFields, reader); ++ currentDepth++; ++ if (currentDepth >= recursionLimit) { ++ throw InvalidProtocolBufferException.recursionLimitExceeded(); ++ } ++ mergeFrom(subFields, reader, currentDepth); ++ currentDepth--; + if (endGroupTag != reader.getTag()) { + throw InvalidProtocolBufferException.invalidEndTag(); + } +@@ -87,10 +99,11 @@ abstract class UnknownFieldSchema { + } + } + +- private final void mergeFrom(B unknownFields, Reader reader) throws IOException { ++ private final void mergeFrom(B unknownFields, Reader reader, int currentDepth) ++ throws IOException { + while (true) { + if (reader.getFieldNumber() == Reader.READ_DONE +- || !mergeOneFieldFrom(unknownFields, reader)) { ++ || !mergeOneFieldFrom(unknownFields, reader, currentDepth)) { + break; + } + } +@@ -107,4 +120,12 @@ abstract class UnknownFieldSchema { + abstract int getSerializedSizeAsMessageSet(T message); + + abstract int getSerializedSize(T unknowns); ++ ++ /** ++ * Set the maximum recursion limit that ArrayDecoders will allow. An exception will be thrown if ++ * the depth of the message exceeds this limit. ++ */ ++ public void setRecursionLimit(int limit) { ++ recursionLimit = limit; ++ } + } +diff --git a/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java b/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java +index 2de3273..70525bb 100644 +--- a/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java ++++ b/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java +@@ -10,6 +10,9 @@ package com.google.protobuf; + import static com.google.common.truth.Truth.assertThat; + import static com.google.common.truth.Truth.assertWithMessage; + import static org.junit.Assert.assertArrayEquals; ++ ++import com.google.common.primitives.Bytes; ++import map_test.MapTestProto.MapContainer; + import protobuf_unittest.UnittestProto.BoolMessage; + import protobuf_unittest.UnittestProto.Int32Message; + import protobuf_unittest.UnittestProto.Int64Message; +@@ -34,6 +37,13 @@ public class CodedInputStreamTest { + + private static final int DEFAULT_BLOCK_SIZE = 4096; + ++ private static final int GROUP_TAP = WireFormat.makeTag(3, WireFormat.WIRETYPE_START_GROUP); ++ ++ private static final byte[] NESTING_SGROUP = generateSGroupTags(); ++ ++ private static final byte[] NESTING_SGROUP_WITH_INITIAL_BYTES = generateSGroupTagsForMapField(); ++ ++ + private enum InputType { + ARRAY { + @Override +@@ -116,6 +126,17 @@ public class CodedInputStreamTest { + return bytes; + } + ++ private static byte[] generateSGroupTags() { ++ byte[] bytes = new byte[100000]; ++ Arrays.fill(bytes, (byte) GROUP_TAP); ++ return bytes; ++ } ++ ++ private static byte[] generateSGroupTagsForMapField() { ++ byte[] initialBytes = {18, 1, 75, 26, (byte) 198, (byte) 154, 12}; ++ return Bytes.concat(initialBytes, NESTING_SGROUP); ++ } ++ + /** + * An InputStream which limits the number of bytes it reads at a time. We use this to make sure + * that CodedInputStream doesn't screw up when reading in small blocks. +@@ -659,6 +680,143 @@ public class CodedInputStreamTest { + } + } + ++ @Test ++ public void testMaliciousRecursion_unknownFields() throws Exception { ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> TestRecursiveMessage.parseFrom(NESTING_SGROUP)); ++ ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testMaliciousRecursion_skippingUnknownField() throws Exception { ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> ++ DiscardUnknownFieldsParser.wrap(TestRecursiveMessage.parser()) ++ .parseFrom(NESTING_SGROUP)); ++ ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTagsWithMapField_fromInputStream() throws Exception { ++ Throwable parseFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> ++ MapContainer.parseFrom( ++ new ByteArrayInputStream(NESTING_SGROUP_WITH_INITIAL_BYTES))); ++ Throwable mergeFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> ++ MapContainer.newBuilder() ++ .mergeFrom(new ByteArrayInputStream(NESTING_SGROUP_WITH_INITIAL_BYTES))); ++ ++ assertThat(parseFromThrown) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ assertThat(mergeFromThrown) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTags_inputStream_skipMessage() throws Exception { ++ ByteArrayInputStream inputSteam = new ByteArrayInputStream(NESTING_SGROUP); ++ CodedInputStream input = CodedInputStream.newInstance(inputSteam); ++ CodedOutputStream output = CodedOutputStream.newInstance(new byte[NESTING_SGROUP.length]); ++ ++ Throwable thrown = assertThrows(InvalidProtocolBufferException.class, input::skipMessage); ++ Throwable thrown2 = ++ assertThrows(InvalidProtocolBufferException.class, () -> input.skipMessage(output)); ++ ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ assertThat(thrown2) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTagsWithMapField_fromByteArray() throws Exception { ++ Throwable parseFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> MapContainer.parseFrom(NESTING_SGROUP_WITH_INITIAL_BYTES)); ++ Throwable mergeFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> MapContainer.newBuilder().mergeFrom(NESTING_SGROUP_WITH_INITIAL_BYTES)); ++ ++ assertThat(parseFromThrown) ++ .hasMessageThat() ++ .contains("the input ended unexpectedly in the middle of a field"); ++ assertThat(mergeFromThrown) ++ .hasMessageThat() ++ .contains("the input ended unexpectedly in the middle of a field"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTags_arrayDecoder_skipMessage() throws Exception { ++ CodedInputStream input = CodedInputStream.newInstance(NESTING_SGROUP); ++ CodedOutputStream output = CodedOutputStream.newInstance(new byte[NESTING_SGROUP.length]); ++ ++ Throwable thrown = assertThrows(InvalidProtocolBufferException.class, input::skipMessage); ++ Throwable thrown2 = ++ assertThrows(InvalidProtocolBufferException.class, () -> input.skipMessage(output)); ++ ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ assertThat(thrown2) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTagsWithMapField_fromByteBuffer() throws Exception { ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> MapContainer.parseFrom(ByteBuffer.wrap(NESTING_SGROUP_WITH_INITIAL_BYTES))); ++ ++ assertThat(thrown) ++ .hasMessageThat() ++ .contains("the input ended unexpectedly in the middle of a field"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTags_byteBuffer_skipMessage() throws Exception { ++ CodedInputStream input = InputType.NIO_DIRECT.newDecoder(NESTING_SGROUP); ++ CodedOutputStream output = CodedOutputStream.newInstance(new byte[NESTING_SGROUP.length]); ++ ++ Throwable thrown = assertThrows(InvalidProtocolBufferException.class, input::skipMessage); ++ Throwable thrown2 = ++ assertThrows(InvalidProtocolBufferException.class, () -> input.skipMessage(output)); ++ ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ assertThat(thrown2) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTags_iterableByteBuffer() throws Exception { ++ CodedInputStream input = InputType.ITER_DIRECT.newDecoder(NESTING_SGROUP); ++ CodedOutputStream output = CodedOutputStream.newInstance(new byte[NESTING_SGROUP.length]); ++ ++ Throwable thrown = assertThrows(InvalidProtocolBufferException.class, input::skipMessage); ++ Throwable thrown2 = ++ assertThrows(InvalidProtocolBufferException.class, () -> input.skipMessage(output)); ++ ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ assertThat(thrown2) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ } ++ + private void checkSizeLimitExceeded(InvalidProtocolBufferException e) { + assertThat(e) + .hasMessageThat() +diff --git a/java/lite/src/test/java/com/google/protobuf/LiteTest.java b/java/lite/src/test/java/com/google/protobuf/LiteTest.java +index b42a4b9..8fed7cd 100644 +--- a/java/lite/src/test/java/com/google/protobuf/LiteTest.java ++++ b/java/lite/src/test/java/com/google/protobuf/LiteTest.java +@@ -2462,6 +2462,211 @@ public class LiteTest { + } + } + ++ @Test ++ public void testParseFromInputStream_concurrent_nestingUnknownGroups() throws Exception { ++ int numThreads = 200; ++ ArrayList threads = new ArrayList<>(); ++ ++ ByteString byteString = generateNestingGroups(99); ++ AtomicBoolean thrown = new AtomicBoolean(false); ++ ++ for (int i = 0; i < numThreads; i++) { ++ Thread thread = ++ new Thread( ++ () -> { ++ try { ++ TestAllTypesLite unused = TestAllTypesLite.parseFrom(byteString); ++ } catch (IOException e) { ++ if (e.getMessage().contains("Protocol message had too many levels of nesting")) { ++ thrown.set(true); ++ } ++ } ++ }); ++ thread.start(); ++ threads.add(thread); ++ } ++ ++ for (Thread thread : threads) { ++ thread.join(); ++ } ++ ++ assertThat(thrown.get()).isFalse(); ++ } ++ ++ @Test ++ public void testParseFromInputStream_nestingUnknownGroups() throws IOException { ++ ByteString byteString = generateNestingGroups(99); ++ ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, () -> TestAllTypesLite.parseFrom(byteString)); ++ assertThat(thrown) ++ .hasMessageThat() ++ .doesNotContain("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testParseFromInputStream_nestingUnknownGroups_exception() throws IOException { ++ ByteString byteString = generateNestingGroups(100); ++ ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, () -> TestAllTypesLite.parseFrom(byteString)); ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testParseFromInputStream_setRecursionLimit_exception() throws IOException { ++ ByteString byteString = generateNestingGroups(199); ++ UnknownFieldSchema schema = SchemaUtil.unknownFieldSetLiteSchema(); ++ schema.setRecursionLimit(200); ++ ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, () -> TestAllTypesLite.parseFrom(byteString)); ++ assertThat(thrown) ++ .hasMessageThat() ++ .doesNotContain("Protocol message had too many levels of nesting"); ++ schema.setRecursionLimit(UnknownFieldSchema.DEFAULT_RECURSION_LIMIT); ++ } ++ ++ @Test ++ public void testParseFromBytes_concurrent_nestingUnknownGroups() throws Exception { ++ int numThreads = 200; ++ ArrayList threads = new ArrayList<>(); ++ ++ ByteString byteString = generateNestingGroups(99); ++ AtomicBoolean thrown = new AtomicBoolean(false); ++ ++ for (int i = 0; i < numThreads; i++) { ++ Thread thread = ++ new Thread( ++ () -> { ++ try { ++ // Should pass in byte[] instead of ByteString to go into ArrayDecoders. ++ TestAllTypesLite unused = TestAllTypesLite.parseFrom(byteString.toByteArray()); ++ } catch (InvalidProtocolBufferException e) { ++ if (e.getMessage().contains("Protocol message had too many levels of nesting")) { ++ thrown.set(true); ++ } ++ } ++ }); ++ thread.start(); ++ threads.add(thread); ++ } ++ ++ for (Thread thread : threads) { ++ thread.join(); ++ } ++ ++ assertThat(thrown.get()).isFalse(); ++ } ++ ++ @Test ++ public void testParseFromBytes_nestingUnknownGroups() throws IOException { ++ ByteString byteString = generateNestingGroups(99); ++ ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> TestAllTypesLite.parseFrom(byteString.toByteArray())); ++ assertThat(thrown) ++ .hasMessageThat() ++ .doesNotContain("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testParseFromBytes_nestingUnknownGroups_exception() throws IOException { ++ ByteString byteString = generateNestingGroups(100); ++ ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> TestAllTypesLite.parseFrom(byteString.toByteArray())); ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testParseFromBytes_setRecursionLimit_exception() throws IOException { ++ ByteString byteString = generateNestingGroups(199); ++ ArrayDecoders.setRecursionLimit(200); ++ ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> TestAllTypesLite.parseFrom(byteString.toByteArray())); ++ assertThat(thrown) ++ .hasMessageThat() ++ .doesNotContain("Protocol message had too many levels of nesting"); ++ ArrayDecoders.setRecursionLimit(ArrayDecoders.DEFAULT_RECURSION_LIMIT); ++ } ++ ++ @Test ++ public void testParseFromBytes_recursiveMessages() throws Exception { ++ byte[] data99 = makeRecursiveMessage(99).toByteArray(); ++ byte[] data100 = makeRecursiveMessage(100).toByteArray(); ++ ++ RecursiveMessage unused = RecursiveMessage.parseFrom(data99); ++ Throwable thrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, () -> RecursiveMessage.parseFrom(data100)); ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testParseFromBytes_recursiveKnownGroups() throws Exception { ++ byte[] data99 = makeRecursiveGroup(99).toByteArray(); ++ byte[] data100 = makeRecursiveGroup(100).toByteArray(); ++ ++ RecursiveGroup unused = RecursiveGroup.parseFrom(data99); ++ Throwable thrown = ++ assertThrows(InvalidProtocolBufferException.class, () -> RecursiveGroup.parseFrom(data100)); ++ assertThat(thrown).hasMessageThat().contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ @SuppressWarnings("ProtoParseFromByteString") ++ public void testMaliciousSGroupTagsWithMapField_fromByteArray() throws Exception { ++ ByteString byteString = generateNestingGroups(102); ++ ++ Throwable parseFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> MapContainer.parseFrom(byteString.toByteArray())); ++ Throwable mergeFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> MapContainer.newBuilder().mergeFrom(byteString.toByteArray())); ++ ++ assertThat(parseFromThrown) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ assertThat(mergeFromThrown) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ } ++ ++ @Test ++ public void testMaliciousSGroupTagsWithMapField_fromInputStream() throws Exception { ++ byte[] bytes = generateNestingGroups(101).toByteArray(); ++ ++ Throwable parseFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> MapContainer.parseFrom(new ByteArrayInputStream(bytes))); ++ Throwable mergeFromThrown = ++ assertThrows( ++ InvalidProtocolBufferException.class, ++ () -> MapContainer.newBuilder().mergeFrom(new ByteArrayInputStream(bytes))); ++ ++ assertThat(parseFromThrown) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ assertThat(mergeFromThrown) ++ .hasMessageThat() ++ .contains("Protocol message had too many levels of nesting"); ++ } ++ + @Test + public void testParseFromByteBuffer_extensions() throws Exception { + TestAllExtensionsLite message = +@@ -2818,4 +3023,31 @@ public class LiteTest { + } + return false; + } ++ ++ private static ByteString generateNestingGroups(int num) throws IOException { ++ int groupTap = WireFormat.makeTag(3, WireFormat.WIRETYPE_START_GROUP); ++ ByteString.Output byteStringOutput = ByteString.newOutput(); ++ CodedOutputStream codedOutput = CodedOutputStream.newInstance(byteStringOutput); ++ for (int i = 0; i < num; i++) { ++ codedOutput.writeInt32NoTag(groupTap); ++ } ++ codedOutput.flush(); ++ return byteStringOutput.toByteString(); ++ } ++ ++ private static RecursiveMessage makeRecursiveMessage(int num) { ++ if (num == 0) { ++ return RecursiveMessage.getDefaultInstance(); ++ } else { ++ return RecursiveMessage.newBuilder().setRecurse(makeRecursiveMessage(num - 1)).build(); ++ } ++ } ++ ++ private static RecursiveGroup makeRecursiveGroup(int num) { ++ if (num == 0) { ++ return RecursiveGroup.getDefaultInstance(); ++ } else { ++ return RecursiveGroup.newBuilder().setRecurse(makeRecursiveGroup(num - 1)).build(); ++ } ++ } + } +-- +2.43.0 + diff --git a/ftdetect-proto.vim b/ftdetect-proto.vim deleted file mode 100644 index e9b063e8a9504dccda06427210f8848ef819a480..0000000000000000000000000000000000000000 --- a/ftdetect-proto.vim +++ /dev/null @@ -1,4 +0,0 @@ -augroup filetype - au! BufRead,BufNewFile *.proto setfiletype proto -augroup end - diff --git a/googletest-5ec7f0c4a113e2f18ac2c6cc7df51ad6afc24081.tar.gz b/googletest-5ec7f0c4a113e2f18ac2c6cc7df51ad6afc24081.tar.gz deleted file mode 100644 index 92e1ec3a7852342bf2d3fb71201bf8af9b84b9f7..0000000000000000000000000000000000000000 Binary files a/googletest-5ec7f0c4a113e2f18ac2c6cc7df51ad6afc24081.tar.gz and /dev/null differ diff --git a/v3.19.6.tar.gz b/protobuf-25.1.tar.gz similarity index 40% rename from v3.19.6.tar.gz rename to protobuf-25.1.tar.gz index 9ed632b2bd5e471942e19a14afcafe693f0e5907..989aa1fec35687ab84229fa84099582dd8f0246a 100644 Binary files a/v3.19.6.tar.gz and b/protobuf-25.1.tar.gz differ diff --git a/protobuf-3.19.4-jre17-add-opens.patch b/protobuf-3.19.4-jre17-add-opens.patch deleted file mode 100644 index 2d159fa6771d398d610538a35a1fe19da9c38488..0000000000000000000000000000000000000000 --- a/protobuf-3.19.4-jre17-add-opens.patch +++ /dev/null @@ -1,10 +0,0 @@ ---- protobuf-3.19.4/java/pom.xml.jre17 2022-02-13 11:45:39.367028268 +0900 -+++ protobuf-3.19.4/java/pom.xml 2022-02-13 12:43:18.212542147 +0900 -@@ -37,6 +37,7 @@ - src/test/proto - ${project.build.directory}/generated-sources - ${project.build.directory}/generated-test-sources -+ --add-opens java.base/java.lang=ALL-UNNAMED - - - diff --git a/protobuf.spec b/protobuf.spec index c22ccab77826c05cfd4b1d651b01d3fc5850b572..89e6bd00cbb960e84ab395e42c0feb0c64701e63 100644 --- a/protobuf.spec +++ b/protobuf.spec @@ -1,427 +1,402 @@ -%define anolis_release 6 -%define googletest_ver 5ec7f0c4a113e2f18ac2c6cc7df51ad6afc24081 -%bcond_without python -%bcond_with java +%define anolis_release 1 + +#needsrootforbuild +%undefine __cmake_in_source_build -%global gtest_url https://github.com/google/googletest -%global gtest_commit 5ec7f0c4a113e2f18ac2c6cc7df51ad6afc24081 -%global gtest_dir googletest-%{gtest_commit} +%define _lto_cflags %{nil} + +# Build -python subpackage +%bcond_without python -Name: protobuf -Version: 3.19.6 -Release: %{anolis_release}%{?dist} -Summary: Protocol Buffers - Google's data interchange format +Summary: Protocol Buffers - Google's data interchange format +Name: protobuf +Version: 25.1 +Release: 11 +License: BSD-3-Clause +URL: https://github.com/protocolbuffers/protobuf +Source: https://github.com/protocolbuffers/protobuf/releases/download/v%{version}%{?rcver}/%{name}-%{version}%{?rcver}.tar.gz +Source1: protobuf-init.el +%global so_version 25.1 + +Patch0: 0001-add-secure-compile-option.patch +Patch1: 0002-Fix-CC-compiler-support.patch +Patch2: 0003-protobuf-add-coverage-compile-option.patch +Patch3: 0004-backport-CVE-2024-7254-1.patch +Patch4: 0004-backport-CVE-2024-7254-2.patch + +BuildRequires: cmake gcc-c++ emacs zlib-devel gmock-devel gtest-devel jsoncpp-devel +BuildRequires: fdupes pkgconfig python-rpm-macros pkgconfig(zlib) ninja-build +BuildRequires: abseil-cpp-devel >= 20230802 -License: BSD -URL: https://github.com/protocolbuffers/protobuf -Source0: https://github.com/protocolbuffers/protobuf/archive/refs/tags/v%{version}.tar.gz +%description -Source1: ftdetect-proto.vim -Source2: protobuf-init.el +Protocol Buffers (a.k.a., protobuf) are Google's language-neutral, +platform-neutral, extensible mechanism for serializing structured data. +You can find protobuf's documentation on the Google Developers site. -# For tests (using exactly the same version as the release) -Source3: %{gtest_url}/archive/%{gtest_commit}/%{gtest_dir}.tar.gz +%package compiler +Summary: Protocol Buffers compiler +Requires: %{name} = %{version}-%{release} +Obsoletes: protobuf-emacs < %{version} +Obsoletes: protobuf-emacs-el < %{version} +Obsoletes: protobuf2-compiler +Requires: emacs-filesystem >= %{_emacs_version} -# Man page hand-written for Fedora in groff_man(7) format based on “protoc -# --help” output. -Source4: protoc.1 +%description compiler +This package containers Protocol Buffers compiler for all programming languages. -Patch3: protobuf-3.19.4-jre17-add-opens.patch -BuildRequires: libtool -BuildRequires: pkgconfig -BuildRequires: zlib-devel -BuildRequires: emacs emacs-common -BuildRequires: make autoconf automake gcc-c++ -%description -Protobuf, short for Protocol Buffers, is a data serialization protocol. It was -developed by Google and was released as an open-source project in 2008. It is -designed to provide a simple and efficient way to serialize structured data for -communication between different systems. - -Protobuf uses a language-neutral data format that can be used to serialize data -in a variety of programming languages such as C++, Java, Python, and Go. This -allows developers to easily share data between different systems written in -different languages. - -The main advantages of using Protobuf are: - -Efficiency: Protobuf generates smaller and faster messages than other -serialization formats such as XML and JSON. This is because Protobuf uses binary -encoding of data. - -Flexibility: Protobuf provides a flexible schema definition language that -allows developers to define complex data structures such as nested objects and -arrays. - -Interoperability: Protobuf provides language-neutral data format that can be -used by different systems written in different languages. - -Extensibility: Protobuf allows developers to add new fields to the schema -without breaking compatibility with existing systems. - -The basic concept of Protobuf is that data is defined in a .proto file, which -is a plain text file that contains the schema definition for the data. The -schema definition includes the data types, fields, and message formats. Once -the schema is defined, a code generator is used to generate source code for the -desired programming language. - -Protobuf messages are composed of fields, each with a unique identifier and a -data type. The data types include basic types such as integers, booleans, and -strings, as well as complex types such as nested objects and arrays. - -Protobuf messages can be encoded and decoded using the provided library for the -desired programming language. The encoded message can then be sent over the -network or saved to disk. - -In summary, Protobuf is a simple and efficient way to serialize structured -data for communication between different systems. Its efficiency, flexibility, -interoperability, and extensibility make it a popular choice for developers who -need to share data between different systems written in different languages. - -%package compiler -Summary: Protocol Buffers compiler +%package devel +Summary: Protocol Buffers C++ headers and libraries Requires: %{name} = %{version}-%{release} - -%description compiler -This package contains Protocol Buffers compiler for all programming -languages +Requires: %{name}-compiler = %{version}-%{release} +Requires: zlib-devel pkgconfig vim-enhanced +Requires: abseil-cpp-devel >= 20230802 +Provides: %{name}-static +Provides: %{name}-vim +Obsoletes: %{name}-static < %{version} +Obsoletes: %{name}-vim < %{version} +Obsoletes: protobuf2-devel +Obsoletes: protobuf2-vim +Obsoletes: protobuf2-static + + +%description devel +This package contains Protocol Buffers compiler for all languages and +C++ headers and libraries -%package static -Summary: Static development files for %{name} -Requires: %{name}-devel = %{version}-%{release} - -%description static -Static libraries for Protocol Buffers - -%package lite +%package lite Summary: Protocol Buffers LITE_RUNTIME libraries -%description lite +%description lite Protocol Buffers built with optimize_for = LITE_RUNTIME. - -The "optimize_for = LITE_RUNTIME" option causes the compiler to generate code -which only depends libprotobuf-lite, which is much smaller than libprotobuf but -lacks descriptors, reflection, and some other features. - -%package lite-static -Summary: Static development files for %{name}-lite -Requires: %{name}-devel = %{version}-%{release} - -%description lite-static -This package contains static development libraries built with -optimize_for = LITE_RUNTIME. The "optimize_for = LITE_RUNTIME" option causes the compiler to generate code which only depends libprotobuf-lite, which is much smaller than libprotobuf but lacks descriptors, reflection, and some other features. -%package lite-devel +%package lite-devel Summary: Protocol Buffers LITE_RUNTIME development libraries Requires: %{name}-devel = %{version}-%{release} Requires: %{name}-lite = %{version}-%{release} - -%description lite-devel +Provides: %{name}-lite-static +Obsoletes: %{name}-lite-static < %{version} +Obsoletes: protobuf2-lite-devel +Obsoletes: protobuf2-lite-static + +%description lite-devel This package contains development libraries built with optimize_for = LITE_RUNTIME. - + The "optimize_for = LITE_RUNTIME" option causes the compiler to generate code which only depends libprotobuf-lite, which is much smaller than libprotobuf but lacks descriptors, reflection, and some other features. %if %{with python} -%package -n python3-%{name} +%package -n python%{python3_pkgversion}-%{name} Summary: Python 3 bindings for Google Protocol Buffers BuildArch: noarch -BuildRequires: python3-devel -BuildRequires: python3-setuptools -BuildRequires: python3-wheel -Requires: python3-six >= 1.9 -Conflicts: %{name}-compiler > %{version} -Conflicts: %{name}-compiler < %{version} +BuildRequires: python%{python3_pkgversion}-devel +BuildRequires: python%{python3_pkgversion}-setuptools +BuildRequires: python%{python3_pkgversion}-wheel +BuildRequires: javapackages-bootstrap +Requires: python%{python3_pkgversion}-six >= 1.9 +Conflicts: %{name}-compiler > %{version}-%{release} +Conflicts: %{name}-compiler < %{version}-%{release} Provides: %{name}-python3 = %{version}-%{release} -%{?python_provide:%python_provide python3-%{name}} - -%description -n python3-%{name} +%{?python_provide:%python_provide python%{python3_pkgversion}-%{name}} + +%description -n python%{python3_pkgversion}-%{name} This package contains Python 3 libraries for Google Protocol Buffers %endif -%package vim -Summary: Vim syntax highlighting for Google Protocol Buffers descriptions -BuildArch: noarch -Requires: vim-enhanced - -%description vim -This package contains syntax highlighting for Google Protocol Buffers -descriptions in Vim editor - -%package emacs -Summary: Emacs mode for Google Protocol Buffers descriptions -BuildArch: noarch -Requires: emacs-filesystem >= %{_emacs_version} -Obsoletes: protobuf-emacs-el < 3.6.1-4 - -%description emacs -This package contains syntax highlighting for Google Protocol Buffers -descriptions in the Emacs editor. %if %{with java} -%package java +%package java Summary: Java Protocol Buffers runtime library BuildArch: noarch -BuildRequires: maven-local -BuildRequires: mvn(com.google.code.gson:gson) -BuildRequires: mvn(com.google.guava:guava) -BuildRequires: mvn(com.google.guava:guava-testlib) -BuildRequires: mvn(com.google.truth:truth) -BuildRequires: mvn(junit:junit) -BuildRequires: mvn(org.apache.felix:maven-bundle-plugin) -BuildRequires: mvn(org.apache.maven.plugins:maven-antrun-plugin) -BuildRequires: mvn(org.apache.maven.plugins:maven-source-plugin) -BuildRequires: mvn(org.codehaus.mojo:build-helper-maven-plugin) -BuildRequires: mvn(org.easymock:easymock) -Conflicts: %{name}-compiler > %{version} -Conflicts: %{name}-compiler < %{version} +BuildRequires: java-devel >= 1.6 +BuildRequires: jpackage-utils +BuildRequires: maven-local +BuildRequires: mvn(com.google.code.gson:gson) +BuildRequires: mvn(com.google.guava:guava) +BuildRequires: mvn(junit:junit) +BuildRequires: mvn(org.easymock:easymock) +BuildRequires: mvn(org.apache.felix:maven-bundle-plugin) +BuildRequires: mvn(org.apache.maven.plugins:maven-antrun-plugin) +BuildRequires: mvn(org.apache.maven.plugins:maven-source-plugin) +BuildRequires: mvn(org.codehaus.mojo:build-helper-maven-plugin) +BuildRequires: maven-compiler-plugin +BuildRequires: maven-install-plugin +BuildRequires: maven-jar-plugin +BuildRequires: maven-javadoc-plugin +BuildRequires: maven-release-plugin +BuildRequires: maven-resources-plugin +BuildRequires: maven-surefire-plugin +BuildRequires: maven-antrun-plugin Obsoletes: %{name}-javanano < 3.6.0 - -%description java + +%description java This package contains Java Protocol Buffers runtime library. - -%package javalite + +%package javalite Summary: Java Protocol Buffers lite runtime library BuildArch: noarch - -%description javalite + +%description javalite This package contains Java Protocol Buffers lite runtime library. - -%package java-util + +%package java-util Summary: Utilities for Protocol Buffers BuildArch: noarch - -%description java-util + +%description java-util Utilities to work with protos. It contains JSON support as well as utilities to work with proto3 well-known types. - -%package javadoc + +%package javadoc Summary: Javadoc for %{name}-java BuildArch: noarch - -%description javadoc + +%description javadoc This package contains the API documentation for %{name}-java. - -%package parent + +%package parent Summary: Protocol Buffer Parent POM BuildArch: noarch - -%description parent + +%description parent Protocol Buffer Parent POM. - -%package bom + +%package bom Summary: Protocol Buffer BOM POM BuildArch: noarch - -%description bom + +%description bom Protocol Buffer BOM POM. %endif -%package devel -Summary: Protocol Buffers C++ headers and libraries -Requires: %{name} = %{version}-%{release} -Requires: %{name}-compiler = %{version}-%{release} -Requires: zlib-devel -Requires: pkgconfig - -%description devel -This package contains Protocol Buffers compiler for all languages and -C++ headers and libraries - -%package doc -Summary: Doc files for %{name} -Requires: %{name} = %{EVR} -BuildArch: noarch - -%description doc -The %{name}-doc package contains documentation files for %{name} - %prep -%setup -q -n %{name}-%{version} -a3 -%patch3 -p1 -b .jre17 - -# Copy in the needed gtest/gmock implementations. -%setup -q -T -D -b 3 -n %{name}-%{version} -rm -rvf 'third_party/googletest' -mv '../%{gtest_dir}' 'third_party/googletest' - +%setup -q -n %{name}-%{version}%{?rcver} +%autopatch -p1 find -name \*.cc -o -name \*.h | xargs chmod -x -chmod 644 examples/* - +find examples -type f | xargs chmod 644 %if %{with java} +#%pom_remove_dep com.google.truth:truth java/pom.xml +#%pom_remove_dep org.easymock:easymockclassextension java/pom.xml java/*/pom.xml +#%pom_remove_dep org.easymock:easymockclassextension java/pom.xml java/core/pom.xml java/lite/pom.xml java/util/pom.xml +%pom_remove_dep com.google.truth:truth java/pom.xml java/util/pom.xml java/lite/pom.xml java/core/pom.xml %pom_remove_dep com.google.errorprone:error_prone_annotations java/util/pom.xml +%pom_remove_dep com.google.guava:guava-testlib java/pom.xml java/util/pom.xml %pom_remove_dep com.google.j2objc:j2objc-annotations java/util/pom.xml -# Remove annotation libraries we don't have -annotations=$( - find -name '*.java' | - xargs grep -h -e '^import com\.google\.errorprone\.annotation' \ - -e '^import com\.google\.j2objc\.annotations' | - sort -u | sed 's/.*\.\([^.]*\);/\1/' | paste -sd\| -) -find -name '*.java' | xargs sed -ri \ - "s/^import .*\.($annotations);//;s/@($annotations)"'\>\s*(\((("[^"]*")|([^)]*))\))?//g' +%pom_remove_plugin org.codehaus.mojo:animal-sniffer-maven-plugin java/pom.xml java/util/pom.xml +%pom_remove_dep org.mockito:mockito-core java/pom.xml java/core/pom.xml java/lite/pom.xml java/util/pom.xml + +# These use easymockclassextension +rm java/core/src/test/java/com/google/protobuf/ServiceTest.java + +#rm -r java/core/src/test + +# These use truth or error_prone_annotations or guava-testlib +rm java/core/src/test/java/com/google/protobuf/LiteralByteStringTest.java +rm java/core/src/test/java/com/google/protobuf/BoundedByteStringTest.java +rm java/core/src/test/java/com/google/protobuf/RopeByteStringTest.java +rm java/core/src/test/java/com/google/protobuf/RopeByteStringSubstringTest.java +rm java/core/src/test/java/com/google/protobuf/TextFormatTest.java +rm java/core/src/test/java/com/google/protobuf/UnknownFieldSetTest.java +rm java/core/src/test/java/com/google/protobuf/UnknownFieldSetPerformanceTest.java +rm -r java/util/src/test/java/com/google/protobuf/util +rm -r java/util/src/main/java/com/google/protobuf/util # Make OSGi dependency on sun.misc package optional %pom_xpath_inject "pom:configuration/pom:instructions" "sun.misc;resolution:=optional,*" java/core - + # Backward compatibility symlink %mvn_file :protobuf-java:jar: %{name}/%{name}-java %{name} +# This test is incredibly slow on arm +# https://github.com/protocolbuffers/protobuf/issues/2389 +%ifarch %{arm} +mv java/core/src/test/java/com/google/protobuf/IsValidUtf8Test.java \ + java/core/src/test/java/com/google/protobuf/IsValidUtf8Test.java.slow +mv java/core/src/test/java/com/google/protobuf/DecodeUtf8Test.java \ + java/core/src/test/java/com/google/protobuf/DecodeUtf8Test.java.slow +%endif %endif rm -f src/solaris/libstdc++.la %build -iconv -f iso8859-1 -t utf-8 CONTRIBUTORS.txt > CONTRIBUTORS.txt.utf8 -mv CONTRIBUTORS.txt.utf8 CONTRIBUTORS.txt -export PTHREAD_LIBS="-lpthread" -./autogen.sh -%configure - -# -Wno-error=type-limits: -# https://github.com/protocolbuffers/protobuf/issues/7514 -# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95148 -# (also set in %%check) -%make_build CXXFLAGS="%{build_cxxflags} -Wno-error=type-limits" +%cmake \ + -B build \ + -Dprotobuf_BUILD_EXAMPLES:BOOL=OFF \ + -Dprotobuf_BUILD_LIBPROTOC:BOOL=ON \ + -Dprotobuf_BUILD_SHARED_LIBS:BOOL=ON \ + -Dprotobuf_USE_EXTERNAL_GTEST:BOOL=ON \ + -Dprotobuf_ABSL_PROVIDER=package \ + -Dprotobuf_BUILD_TESTS:BOOL=OFF \ + -DCMAKE_EXE_LINKER_FLAGS="%{build_ldflags}" \ + -DCMAKE_SHARED_LINKER_FLAGS="%{build_ldflags}" \ + -DCMAKE_CXX_FLAGS="%{build_cxxflags} %{?_ld_as_needed_flags}" \ + -DCMAKE_C_COMPILER=%{__cc} \ + -DCMAKE_CXX_COMPILER=%{__cxx} \ + -DCMAKE_SKIP_RPATH=TRUE \ + -G Ninja + +%ninja_build -C build + +%cmake \ + -B build-static \ + -Dprotobuf_BUILD_EXAMPLES:BOOL=OFF \ + -Dprotobuf_BUILD_LIBPROTOC:BOOL=ON \ + -Dprotobuf_BUILD_SHARED_LIBS:BOOL=OFF \ + -Dprotobuf_USE_EXTERNAL_GTEST:BOOL=ON \ + -Dprotobuf_ABSL_PROVIDER=package \ + -Dprotobuf_BUILD_TESTS:BOOL=OFF \ + -DCMAKE_CXX_FLAGS="-fPIC" \ + -DCMAKE_C_COMPILER=%{__cc} \ + -DCMAKE_CXX_COMPILER=%{__cxx} \ + -DCMAKE_SKIP_RPATH=TRUE \ + -G Ninja + +%ninja_build -C build-static + +# we have to override LD_LIBRARY_PATH because we eliminated rpath +export LD_LIBRARY_PATH="${PWD}/build":$LD_LIBRARY_PATH %if %{with python} +# Use the just built protoc instead of any +# system version for python and/or java bindings +export PROTOC=../build/protoc pushd python +CXXFLAGS="%{build_cxxflags}" \ +LDFLAGS="-L../%{_vpath_builddir} -L../%{_vpath_builddir}/third_party/utf8_range %{build_ldflags}" \ %py3_build popd %endif %if %{with java} +cp build/protoc ./ %pom_disable_module kotlin java/pom.xml %pom_disable_module kotlin-lite java/pom.xml -%mvn_build -s -- -f java/pom.xml +%mvn_build -s -- -Dmaven.test.skip=true -f java/pom.xml %endif %{_emacs_bytecompile} editors/protobuf-mode.el +%check +# Java tests fail on s390x +%ifarch s390x +fail=0 +%else +fail=1 +%endif + + %install -%make_install STRIPBINARIES=no INSTALL="%{__install} -p" CPPROG="cp -p" +%ninja_install -C build-static +%ninja_install -C build -# protoc.1 man page -install -p -m 0644 -D -t '%{buildroot}%{_mandir}/man1' %{SOURCE4} - %if %{with python} pushd python +CXXFLAGS="%{build_cxxflags}" \ +LDFLAGS="-L../%{_vpath_builddir} -L../%{_vpath_builddir}/third_party/utf8_range %{build_ldflags}" \ +#python ./setup.py install --root=%{buildroot} --single-version-externally-managed --record=INSTALLED_FILES --optimize=1 %py3_install find %{buildroot}%{python3_sitelib} -name \*.py | xargs sed -i -e '1{\@^#!@d}' popd %endif -install -p -m 0644 -D %{SOURCE1} %{buildroot}%{_datadir}/vim/vimfiles/ftdetect/proto.vim -install -p -m 0644 -D editors/proto.vim %{buildroot}%{_datadir}/vim/vimfiles/syntax/proto.vim - +install -p -m 644 -D editors/proto.vim %{buildroot}%{_datadir}/vim/vimfiles/syntax/proto.vim %if %{with java} %mvn_install %endif mkdir -p %{buildroot}%{_emacs_sitelispdir}/%{name} -install -m 0644 -p editors/protobuf-mode.el %{buildroot}%{_emacs_sitelispdir}/%{name} -install -m 0644 -p editors/protobuf-mode.elc %{buildroot}%{_emacs_sitelispdir}/%{name} +install -p -m 0644 editors/protobuf-mode.el %{buildroot}%{_emacs_sitelispdir}/%{name} +install -p -m 0644 editors/protobuf-mode.elc %{buildroot}%{_emacs_sitelispdir}/%{name} mkdir -p %{buildroot}%{_emacs_sitestartdir} -install -m 0644 -p %{SOURCE2} %{buildroot}%{_emacs_sitestartdir} - -%generate_compatibility_deps - -%check -fail=1 -%make_build check CXXFLAGS="%{build_cxxflags} -Wno-error=type-limits" || exit $fail +install -p -m 0644 %{SOURCE1} %{buildroot}%{_emacs_sitestartdir} %files -%dir %{abidir} -%{_libdir}/libprotobuf.so.30* -%{abidir}/libprotobuf.dump -%{abidir}/protoc-option.list +%doc CONTRIBUTORS.txt README.md %license LICENSE +%{_libdir}/libprotobuf.so.%{so_version}{,.*} -%files compiler -%doc README.md +%files compiler +%{_bindir}/protoc* +%{_libdir}/libprotoc.so.%{so_version}{,.*} +%{_emacs_sitelispdir}/%{name}/ +%{_emacs_sitestartdir}/protobuf-init.el %license LICENSE -%{_bindir}/protoc -%{_mandir}/man1/protoc.1* -%{_libdir}/libprotoc.so.30* -%{abidir}/libprotoc.dump +%doc README.md %files devel -%{_libdir}/libprotoc.so -%{_libdir}/libprotobuf.so %dir %{_includedir}/google %{_includedir}/google/protobuf/ +%{_includedir}/utf8_range.h +%{_includedir}/utf8_validity.h +%{_libdir}/libprotobuf.so +%{_libdir}/libprotoc.so %{_libdir}/pkgconfig/protobuf.pc -%doc examples/add_person.cc examples/addressbook.proto -%doc examples/list_people.cc examples/Makefile examples/README.md - -%files emacs -%{_emacs_sitelispdir}/%{name}/ -%{_emacs_sitestartdir}/protobuf-init.el - -%files static -%{_libdir}/libprotoc.a +%{_libdir}/pkgconfig/utf8_range.pc +%doc examples/add_person.cc examples/addressbook.proto examples/list_people.cc examples/Makefile examples/README.md %{_libdir}/libprotobuf.a - +%{_libdir}/libprotoc.a +%{_datadir}/vim/vimfiles/syntax/proto.vim +%{_libdir}/cmake/utf8_range +%{_libdir}/cmake/protobuf +%{_libdir}/libutf8_range.a +%{_libdir}/libutf8_validity.a +%{_includedir}/java/core/src/main/java/com/google/protobuf/java_features.proto + %files lite -%{_libdir}/libprotobuf-lite.so.30* -%{abidir}/libprotobuf-lite.dump +%{_libdir}/libprotobuf-lite.so.%{so_version}{,.*} %files lite-devel %{_libdir}/libprotobuf-lite.so %{_libdir}/pkgconfig/protobuf-lite.pc - -%files lite-static %{_libdir}/libprotobuf-lite.a %if %{with python} -%files -n python3-protobuf -%doc python/README.md +%files -n python%{python3_pkgversion}-protobuf %dir %{python3_sitelib}/google %{python3_sitelib}/google/protobuf/ -%{python3_sitelib}/protobuf-%{version}%{?rcver}-py3.*.egg-info/ -%{python3_sitelib}/protobuf-%{version}%{?rcver}-py3.*-nspkg.pth +%{python3_sitelib}/%{name}-*-py3.*.egg-info/ +%{python3_sitelib}/%{name}-*-py3.*-nspkg.pth +%doc python/README.md %doc examples/add_person.py examples/list_people.py examples/addressbook.proto %endif -%files vim -%{_datadir}/vim/vimfiles/syntax/proto.vim -%{_datadir}/vim/vimfiles/ftdetect/proto.vim - %if %{with java} %files java -f .mfiles-protobuf-java -%license LICENSE %doc examples/AddPerson.java examples/ListPeople.java %doc java/README.md - +%license LICENSE +%{_includedir}/java/core/src/main/java/com/google/protobuf/java_features.proto + %files java-util -f .mfiles-protobuf-java-util - + %files javadoc -f .mfiles-javadoc %license LICENSE - + %files parent -f .mfiles-protobuf-parent %license LICENSE - + %files bom -f .mfiles-protobuf-bom %license LICENSE - + %files javalite -f .mfiles-protobuf-javalite %license LICENSE %endif -%files doc -%doc CHANGES.txt CONTRIBUTORS.txt README.md - %changelog +* Thu Jun 19 2025 zjl02254423 - 25.1-1 +- update to 25.1 ro fix CVE-2024-2410 + * Wed Mar 13 2024 Zhao Hang - 3.19.6-6 - Rebuild with python3.11 diff --git a/protobuf.yaml b/protobuf.yaml new file mode 100644 index 0000000000000000000000000000000000000000..06f6fb723fd799e86e4c0400e518cc6f43d0521d --- /dev/null +++ b/protobuf.yaml @@ -0,0 +1,933 @@ +--- +version_control: github +src_repo: protocolbuffers/protobuf +tag_prefix: "Protocol Buffers v" +seperator: "." +last_query: + time_stamp: 2020-07-01 16:39:21.463874585 +08:00 + raw_data: + { + "assets": [ + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-all-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:23Z", + "download_count": 5468, + "id": 21308501, + "label": null, + "name": "protobuf-all-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTAx", + "size": 7561788, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:33Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308501" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-all-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:33Z", + "download_count": 5169, + "id": 21308507, + "label": null, + "name": "protobuf-all-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTA3", + "size": 9759206, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:35Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308507" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-cpp-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:35Z", + "download_count": 3711, + "id": 21308508, + "label": null, + "name": "protobuf-cpp-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTA4", + "size": 4631996, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:36Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308508" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-cpp-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:36Z", + "download_count": 2292, + "id": 21308509, + "label": null, + "name": "protobuf-cpp-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTA5", + "size": 5657857, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:37Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308509" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-csharp-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:37Z", + "download_count": 156, + "id": 21308510, + "label": null, + "name": "protobuf-csharp-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTEw", + "size": 5297300, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:38Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308510" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-csharp-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:38Z", + "download_count": 834, + "id": 21308511, + "label": null, + "name": "protobuf-csharp-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTEx", + "size": 6532421, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:38Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308511" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-java-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:38Z", + "download_count": 666, + "id": 21308512, + "label": null, + "name": "protobuf-java-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTEy", + "size": 5313409, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:39Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308512" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-java-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:39Z", + "download_count": 1549, + "id": 21308513, + "label": null, + "name": "protobuf-java-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTEz", + "size": 6680901, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:40Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308513" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-js-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:40Z", + "download_count": 118, + "id": 21308514, + "label": null, + "name": "protobuf-js-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTE0", + "size": 4877626, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:41Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308514" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-js-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:41Z", + "download_count": 319, + "id": 21308515, + "label": null, + "name": "protobuf-js-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTE1", + "size": 6051862, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:41Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308515" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-objectivec-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:41Z", + "download_count": 83, + "id": 21308516, + "label": null, + "name": "protobuf-objectivec-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTE2", + "size": 5021529, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:42Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308516" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-objectivec-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:42Z", + "download_count": 190, + "id": 21308521, + "label": null, + "name": "protobuf-objectivec-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTIx", + "size": 6226451, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:43Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308521" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-php-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:43Z", + "download_count": 132, + "id": 21308523, + "label": null, + "name": "protobuf-php-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTIz", + "size": 4982631, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:43Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308523" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-php-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:43Z", + "download_count": 158, + "id": 21308524, + "label": null, + "name": "protobuf-php-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTI0", + "size": 6130092, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:44Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308524" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-python-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:44Z", + "download_count": 872, + "id": 21308525, + "label": null, + "name": "protobuf-python-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTI1", + "size": 4954883, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:45Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308525" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-python-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:45Z", + "download_count": 1468, + "id": 21308528, + "label": null, + "name": "protobuf-python-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTI4", + "size": 6099055, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:46Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308528" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-ruby-3.12.3.tar.gz", + "content_type": "application/x-gzip", + "created_at": "2020-06-03T01:07:46Z", + "download_count": 43, + "id": 21308529, + "label": null, + "name": "protobuf-ruby-3.12.3.tar.gz", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTI5", + "size": 4904683, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:46Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308529" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protobuf-ruby-3.12.3.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:46Z", + "download_count": 42, + "id": 21308530, + "label": null, + "name": "protobuf-ruby-3.12.3.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTMw", + "size": 5985566, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:47Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308530" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-linux-aarch_64.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:47Z", + "download_count": 360, + "id": 21308531, + "label": null, + "name": "protoc-3.12.3-linux-aarch_64.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTMx", + "size": 1498113, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:47Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308531" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-linux-ppcle_64.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:47Z", + "download_count": 49, + "id": 21308533, + "label": null, + "name": "protoc-3.12.3-linux-ppcle_64.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTMz", + "size": 1653545, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:48Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308533" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-linux-s390x.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:48Z", + "download_count": 39, + "id": 21308534, + "label": null, + "name": "protoc-3.12.3-linux-s390x.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTM0", + "size": 1558419, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:48Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308534" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-linux-x86_32.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:48Z", + "download_count": 139, + "id": 21308535, + "label": null, + "name": "protoc-3.12.3-linux-x86_32.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTM1", + "size": 1550746, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:49Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308535" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-linux-x86_64.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:49Z", + "download_count": 16134, + "id": 21308536, + "label": null, + "name": "protoc-3.12.3-linux-x86_64.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTM2", + "size": 1609207, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:49Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308536" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-osx-x86_64.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:49Z", + "download_count": 4283, + "id": 21308537, + "label": null, + "name": "protoc-3.12.3-osx-x86_64.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTM3", + "size": 2533079, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:50Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308537" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-win32.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:50Z", + "download_count": 1641, + "id": 21308538, + "label": null, + "name": "protoc-3.12.3-win32.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTM4", + "size": 1117612, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:50Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308538" + }, + { + "browser_download_url": "https://github.com/protocolbuffers/protobuf/releases/download/v3.12.3/protoc-3.12.3-win64.zip", + "content_type": "application/zip", + "created_at": "2020-06-03T01:07:50Z", + "download_count": 11297, + "id": 21308539, + "label": null, + "name": "protoc-3.12.3-win64.zip", + "node_id": "MDEyOlJlbGVhc2VBc3NldDIxMzA4NTM5", + "size": 1451052, + "state": "uploaded", + "updated_at": "2020-06-03T01:07:50Z", + "uploader": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/assets/21308539" + } + ], + "assets_url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/27159058/assets", + "author": { + "avatar_url": "https://avatars2.githubusercontent.com/u/1270?v=4", + "events_url": "https://api.github.com/users/haberman/events{/privacy}", + "followers_url": "https://api.github.com/users/haberman/followers", + "following_url": "https://api.github.com/users/haberman/following{/other_user}", + "gists_url": "https://api.github.com/users/haberman/gists{/gist_id}", + "gravatar_id": "", + "html_url": "https://github.com/haberman", + "id": 1270, + "login": "haberman", + "node_id": "MDQ6VXNlcjEyNzA=", + "organizations_url": "https://api.github.com/users/haberman/orgs", + "received_events_url": "https://api.github.com/users/haberman/received_events", + "repos_url": "https://api.github.com/users/haberman/repos", + "site_admin": false, + "starred_url": "https://api.github.com/users/haberman/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/haberman/subscriptions", + "type": "User", + "url": "https://api.github.com/users/haberman" + }, + "body": "# Objective-C\r\n * Tweak the union used for Extensions to support old generated code. #7573", + "created_at": "2020-06-02T22:12:47Z", + "draft": false, + "html_url": "https://github.com/protocolbuffers/protobuf/releases/tag/v3.12.3", + "id": 27159058, + "name": "Protocol Buffers v3.12.3", + "node_id": "MDc6UmVsZWFzZTI3MTU5MDU4", + "prerelease": false, + "published_at": "2020-06-03T01:17:07Z", + "tag_name": "v3.12.3", + "tarball_url": "https://api.github.com/repos/protocolbuffers/protobuf/tarball/v3.12.3", + "target_commitish": "master", + "upload_url": "https://uploads.github.com/repos/protocolbuffers/protobuf/releases/27159058/assets{?name,label}", + "url": "https://api.github.com/repos/protocolbuffers/protobuf/releases/27159058", + "zipball_url": "https://api.github.com/repos/protocolbuffers/protobuf/zipball/v3.12.3" + } +query_type: api.github.releases \ No newline at end of file diff --git a/protoc.1 b/protoc.1 deleted file mode 100644 index 71e0bd588f4b37f2ac7abea6197905532b22da5c..0000000000000000000000000000000000000000 --- a/protoc.1 +++ /dev/null @@ -1,193 +0,0 @@ -.TH protoc "1" "December 2022" protoc "User Commands" -.SH NAME -protoc \- Protobuf compiler -.SH SYNOPSIS -protoc -.RI [ OPTION ] -.I PROTO_FILES -.SH DESCRIPTION -.PP -Parse -.I PROTO_FILES -and generate output based on the options given. -.SH OPTIONS -.TP -.B \-I\fIPATH\fR, \fB\-\-proto_path=\fIPATH -Specify the directory in which to search for imports. -May be specified multiple times; directories will be searched in order. -If not given, the current working directory is used. -If not found in any of the these directories, the -.B \-\-descriptor_set_in -descriptors will be checked for required proto file. -.TP -.B \-\-version -Show version info and exit. -.TP -.B \-h\fR, \fB\-\-help -Show a help message and exit. -.TP -.BI \-\-encode= MESSAGE_TYPE -Read a text-format message of the given type -from standard input and write it in binary -to standard output. -The message type must be defined in -.I PROTO_FILES -or their imports. -.TP -.B \-\-deterministic_output -When using -.BR \-\-encode , -ensure map fields are deterministically ordered. -Note that this order is not canonical, -and changes across builds or releases of -.BR protoc (1). -.TP -.BI \-\-decode= MESSAGE_TYPE -Read a binary message of the given type -from standard input and write it in text format -to standard output. -The message type must be defined in -.I PROTO_FILES -or their imports. -.TP -.B \-\-decode_raw -Read an arbitrary protocol message -from standard input and write the raw tag/value pairs in text format -to standard output. -No -.I PROTO_FILES -should be given when using this flag. -.TP -.BI \-\-descriptor_set_in= FILES -Specifies a delimited list of -.I FILES -each containing a -.B FileDescriptorSet -(a protocol buffer defined in -.BR descriptor.proto ). -The -.B FileDescriptor -for each of the -.I PROTO_FILES -provided will be loaded from these -.BR FileDescriptorSets . -If a -.B FileDescriptor -appears multiple times, the first occurrence will be used. -.TP -.B \-o\fIFILE\fR, \fB\-\-descriptor_set_out=\fIFILE -Writes a -.B FileDescriptorSet -(a protocol buffer, defined in -.BR descriptor.proto ) -containing all of the input files to -.IR FILE . -.TP -.B \-\-include_imports -When using -.BR \-\-descriptor_set_out , -also include all dependencies of the input files in the set, -so that the set is self-contained. -.TP -.B \-\-include_source_info -When using -.BR \-\-descriptor_set_out , -do not strip -.B SourceCodeInfo -from the -.BR FileDescriptorProto . -This results in vastly larger descriptors -that include information about the original location -of each decl in the source file -as well as surrounding comments. -.TP -.BI \-\-dependency_out= FILE -Write a dependency output file in the format expected by -.BR make (1). -This writes the transitive set of input file paths to -.I FILE -.TP -.BI \-\-error_format= FORMAT -Set the format in which to print errors. -.I FORMAT -may be -.RB \(oq gcc \(cq -(the default) or -.RP \(oq msvs \(cq -(Microsoft Visual Studio format). -.TP -.B \-\-fatal_warnings -Make warnings be fatal (similar to -.B \-Werr -in -.BR gcc (1)). -This flag will make -.BR protoc (1) - return with a non-zero exit code -if any warnings are generated. -.TP -.B \-\-print_free_field_numbers -Print the free field numbers of the messages -defined in the given proto files. -Groups share the same field number space with the parent message. -Extension ranges are counted as occupied fields numbers. -.TP -.BI \-\-plugin= EXECUTABLE -Specifies a plugin executable to use. -Normally, -.BR protoc (1) -searches the -.B PATH -for plugins, but you may specify additional executables -not in the path using this flag. -Additionally, -.I EXECUTABLE -may be of the form -.BR NAME=\fIPATH , -in which case the given plugin name -is mapped to the given executable -even if the executable\(cqs own name differs. -.TP -.BI \-\-cpp_out= OUT_DIR -Generate C++ header and source. -.TP -.BI \-\-csharp_out= OUT_DIR -Generate C# source file. -.TP -.BI \-\-java_out= OUT_DIR -Generate Java source file. -.TP -.BI \-\-js_out= OUT_DIR -Generate JavaScript source. -.TP -.BI \-\-kotlin_out= OUT_DIR -Generate Kotlin file. -.TP -.BI \-\-objc_out= OUT_DIR -Generate Objective-C header and source. -.TP -.BI \-\-php_out= OUT_DIR -Generate PHP source file. -.TP -.BI \-\-python_out= OUT_DIR -Generate Python source file. -.TP -.BI \-\-ruby_out= OUT_DIR -Generate Ruby source file. -.TP -.BI @ -Read options and filenames from file. -If a relative file path is specified, -the file will be searched in the working directory. -The -.B \-\-proto_path -option will not affect how this argument file is searched. -Content of the file will be expanded in the position of -.BI @ -as in the argument list. -Note that shell expansion is not applied to the content of the file -(i.e., you cannot use quotes, wildcards, escapes, commands, etc.). -Each line corresponds to a single argument, even if it contains spaces. -.SH "SEE ALSO" -.BR make (1), -.BR gcc (1)