217 lines
9.8 KiB
Java
217 lines
9.8 KiB
Java
package io.grpc.internal;
|
|
|
|
import com.google.common.base.Charsets;
|
|
import com.google.common.base.Preconditions;
|
|
import io.grpc.InternalMetadata;
|
|
import io.grpc.InternalStatus;
|
|
import io.grpc.Metadata;
|
|
import io.grpc.Status;
|
|
import io.grpc.internal.AbstractClientStream;
|
|
import java.nio.charset.Charset;
|
|
import net.sf.scuba.smartcards.ISO7816;
|
|
import okhttp3.internal.http2.Header;
|
|
|
|
/* loaded from: classes6.dex */
|
|
public abstract class Http2ClientStreamTransportState extends AbstractClientStream.TransportState {
|
|
private static final Metadata.Key<Integer> HTTP2_STATUS;
|
|
private static final InternalMetadata.TrustedAsciiMarshaller<Integer> HTTP_STATUS_MARSHALLER;
|
|
private Charset errorCharset;
|
|
private boolean headersReceived;
|
|
private Status transportError;
|
|
private Metadata transportErrorMetadata;
|
|
|
|
protected abstract void http2ProcessingFailed(Status status, boolean z, Metadata metadata);
|
|
|
|
@Override // io.grpc.internal.AbstractClientStream.TransportState, io.grpc.internal.MessageDeframer.Listener
|
|
public /* bridge */ /* synthetic */ void deframerClosed(boolean z) {
|
|
super.deframerClosed(z);
|
|
}
|
|
|
|
static {
|
|
InternalMetadata.TrustedAsciiMarshaller<Integer> trustedAsciiMarshaller = new InternalMetadata.TrustedAsciiMarshaller<Integer>() { // from class: io.grpc.internal.Http2ClientStreamTransportState.1
|
|
@Override // io.grpc.Metadata.TrustedAsciiMarshaller
|
|
public byte[] toAsciiString(Integer num) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // io.grpc.Metadata.TrustedAsciiMarshaller
|
|
public Integer parseAsciiString(byte[] bArr) {
|
|
if (bArr.length >= 3) {
|
|
return Integer.valueOf(((bArr[0] + ISO7816.INS_WRITE_BINARY) * 100) + ((bArr[1] + ISO7816.INS_WRITE_BINARY) * 10) + bArr[2] + ISO7816.INS_WRITE_BINARY);
|
|
}
|
|
throw new NumberFormatException("Malformed status code ".concat(new String(bArr, InternalMetadata.US_ASCII)));
|
|
}
|
|
};
|
|
HTTP_STATUS_MARSHALLER = trustedAsciiMarshaller;
|
|
HTTP2_STATUS = InternalMetadata.keyOf(Header.RESPONSE_STATUS_UTF8, trustedAsciiMarshaller);
|
|
}
|
|
|
|
public Http2ClientStreamTransportState(int i, StatsTraceContext statsTraceContext, TransportTracer transportTracer) {
|
|
super(i, statsTraceContext, transportTracer);
|
|
this.errorCharset = Charsets.UTF_8;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
/* JADX WARN: Finally extract failed */
|
|
public void transportHeadersReceived(Metadata metadata) {
|
|
Preconditions.checkNotNull(metadata, "headers");
|
|
Status status = this.transportError;
|
|
if (status != null) {
|
|
this.transportError = status.augmentDescription("headers: ".concat(String.valueOf(metadata)));
|
|
return;
|
|
}
|
|
try {
|
|
if (this.headersReceived) {
|
|
Status withDescription = Status.INTERNAL.withDescription("Received headers twice");
|
|
this.transportError = withDescription;
|
|
if (withDescription != null) {
|
|
this.transportError = withDescription.augmentDescription("headers: ".concat(String.valueOf(metadata)));
|
|
this.transportErrorMetadata = metadata;
|
|
this.errorCharset = extractCharset(metadata);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
Integer num = (Integer) metadata.get(HTTP2_STATUS);
|
|
if (num != null && num.intValue() >= 100 && num.intValue() < 200) {
|
|
Status status2 = this.transportError;
|
|
if (status2 != null) {
|
|
this.transportError = status2.augmentDescription("headers: ".concat(String.valueOf(metadata)));
|
|
this.transportErrorMetadata = metadata;
|
|
this.errorCharset = extractCharset(metadata);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
this.headersReceived = true;
|
|
Status validateInitialMetadata = validateInitialMetadata(metadata);
|
|
this.transportError = validateInitialMetadata;
|
|
if (validateInitialMetadata != null) {
|
|
if (validateInitialMetadata != null) {
|
|
this.transportError = validateInitialMetadata.augmentDescription("headers: ".concat(String.valueOf(metadata)));
|
|
this.transportErrorMetadata = metadata;
|
|
this.errorCharset = extractCharset(metadata);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
stripTransportDetails(metadata);
|
|
inboundHeadersReceived(metadata);
|
|
Status status3 = this.transportError;
|
|
if (status3 != null) {
|
|
this.transportError = status3.augmentDescription("headers: ".concat(String.valueOf(metadata)));
|
|
this.transportErrorMetadata = metadata;
|
|
this.errorCharset = extractCharset(metadata);
|
|
}
|
|
} catch (Throwable th) {
|
|
Status status4 = this.transportError;
|
|
if (status4 != null) {
|
|
this.transportError = status4.augmentDescription("headers: ".concat(String.valueOf(metadata)));
|
|
this.transportErrorMetadata = metadata;
|
|
this.errorCharset = extractCharset(metadata);
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public void transportDataReceived(ReadableBuffer readableBuffer, boolean z) {
|
|
Status status = this.transportError;
|
|
if (status != null) {
|
|
StringBuilder sb = new StringBuilder("DATA-----------------------------\n");
|
|
sb.append(ReadableBuffers.readAsString(readableBuffer, this.errorCharset));
|
|
this.transportError = status.augmentDescription(sb.toString());
|
|
readableBuffer.close();
|
|
if (this.transportError.getDescription().length() > 1000 || z) {
|
|
http2ProcessingFailed(this.transportError, false, this.transportErrorMetadata);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (!this.headersReceived) {
|
|
http2ProcessingFailed(Status.INTERNAL.withDescription("headers not received before payload"), false, new Metadata());
|
|
return;
|
|
}
|
|
int readableBytes = readableBuffer.readableBytes();
|
|
inboundDataReceived(readableBuffer);
|
|
if (z) {
|
|
if (readableBytes > 0) {
|
|
this.transportError = Status.INTERNAL.withDescription("Received unexpected EOS on non-empty DATA frame from server");
|
|
} else {
|
|
this.transportError = Status.INTERNAL.withDescription("Received unexpected EOS on empty DATA frame from server");
|
|
}
|
|
Metadata metadata = new Metadata();
|
|
this.transportErrorMetadata = metadata;
|
|
transportReportStatus(this.transportError, false, metadata);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public void transportTrailersReceived(Metadata metadata) {
|
|
Preconditions.checkNotNull(metadata, GrpcUtil.TE_TRAILERS);
|
|
if (this.transportError == null && !this.headersReceived) {
|
|
Status validateInitialMetadata = validateInitialMetadata(metadata);
|
|
this.transportError = validateInitialMetadata;
|
|
if (validateInitialMetadata != null) {
|
|
this.transportErrorMetadata = metadata;
|
|
}
|
|
}
|
|
Status status = this.transportError;
|
|
if (status != null) {
|
|
Status augmentDescription = status.augmentDescription("trailers: ".concat(String.valueOf(metadata)));
|
|
this.transportError = augmentDescription;
|
|
http2ProcessingFailed(augmentDescription, false, this.transportErrorMetadata);
|
|
} else {
|
|
Status statusFromTrailers = statusFromTrailers(metadata);
|
|
stripTransportDetails(metadata);
|
|
inboundTrailersReceived(metadata, statusFromTrailers);
|
|
}
|
|
}
|
|
|
|
private Status statusFromTrailers(Metadata metadata) {
|
|
Status withDescription;
|
|
Status status = (Status) metadata.get(InternalStatus.CODE_KEY);
|
|
if (status != null) {
|
|
return status.withDescription((String) metadata.get(InternalStatus.MESSAGE_KEY));
|
|
}
|
|
if (this.headersReceived) {
|
|
return Status.UNKNOWN.withDescription("missing GRPC status in response");
|
|
}
|
|
Integer num = (Integer) metadata.get(HTTP2_STATUS);
|
|
if (num != null) {
|
|
withDescription = GrpcUtil.httpStatusToGrpcStatus(num.intValue());
|
|
} else {
|
|
withDescription = Status.INTERNAL.withDescription("missing HTTP status code");
|
|
}
|
|
return withDescription.augmentDescription("missing GRPC status, inferred error from HTTP status code");
|
|
}
|
|
|
|
private Status validateInitialMetadata(Metadata metadata) {
|
|
Integer num = (Integer) metadata.get(HTTP2_STATUS);
|
|
if (num == null) {
|
|
return Status.INTERNAL.withDescription("Missing HTTP status code");
|
|
}
|
|
String str = (String) metadata.get(GrpcUtil.CONTENT_TYPE_KEY);
|
|
if (GrpcUtil.isGrpcContentType(str)) {
|
|
return null;
|
|
}
|
|
return GrpcUtil.httpStatusToGrpcStatus(num.intValue()).augmentDescription("invalid content-type: ".concat(String.valueOf(str)));
|
|
}
|
|
|
|
private static Charset extractCharset(Metadata metadata) {
|
|
String str = (String) metadata.get(GrpcUtil.CONTENT_TYPE_KEY);
|
|
if (str != null) {
|
|
try {
|
|
return Charset.forName(str.split("charset=", 2)[r2.length - 1].trim());
|
|
} catch (Exception unused) {
|
|
}
|
|
}
|
|
return Charsets.UTF_8;
|
|
}
|
|
|
|
private static void stripTransportDetails(Metadata metadata) {
|
|
metadata.discardAll(HTTP2_STATUS);
|
|
metadata.discardAll(InternalStatus.CODE_KEY);
|
|
metadata.discardAll(InternalStatus.MESSAGE_KEY);
|
|
}
|
|
}
|