PushCertificateIdent.java
/*
* Copyright (C) 2015, Google Inc. and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.transport;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.eclipse.jgit.util.RawParseUtils.lastIndexOfTrim;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.util.MutableInteger;
import org.eclipse.jgit.util.RawParseUtils;
/**
* Identity in a push certificate.
* <p>
* This is similar to a {@link org.eclipse.jgit.lib.PersonIdent} in that it
* contains a name, timestamp, and timezone offset, but differs in the following
* ways:
* <ul>
* <li>It is always parsed from a UTF-8 string, rather than a raw commit
* buffer.</li>
* <li>It is not guaranteed to contain a name and email portion, since any UTF-8
* string is a valid OpenPGP User ID (RFC4880 5.1.1). The raw User ID is always
* available as {@link #getUserId()}, but {@link #getEmailAddress()} may return
* null.</li>
* <li>The raw text from which the identity was parsed is available with
* {@link #getRaw()}. This is necessary for losslessly reconstructing the signed
* push certificate payload.</li>
* <li>
* </ul>
*
* @since 4.1
*/
public class PushCertificateIdent {
/**
* Parse an identity from a string.
* <p>
* Spaces are trimmed when parsing the timestamp and timezone offset, with
* one exception. The timestamp must be preceded by a single space, and the
* rest of the string prior to that space (including any additional
* whitespace) is treated as the OpenPGP User ID.
* <p>
* If either the timestamp or timezone offsets are missing, mimics
* {@link RawParseUtils#parsePersonIdent(String)} behavior and sets them
* both to zero.
*
* @param str
* string to parse.
* @return a {@link org.eclipse.jgit.transport.PushCertificateIdent} object.
*/
public static PushCertificateIdent parse(String str) {
MutableInteger p = new MutableInteger();
byte[] raw = str.getBytes(UTF_8);
int tzBegin = raw.length - 1;
tzBegin = lastIndexOfTrim(raw, ' ', tzBegin);
if (tzBegin < 0 || raw[tzBegin] != ' ') {
return new PushCertificateIdent(str, str, 0, 0);
}
int whenBegin = tzBegin++;
int tz = RawParseUtils.parseTimeZoneOffset(raw, tzBegin, p);
boolean hasTz = p.value != tzBegin;
whenBegin = lastIndexOfTrim(raw, ' ', whenBegin);
if (whenBegin < 0 || raw[whenBegin] != ' ') {
return new PushCertificateIdent(str, str, 0, 0);
}
int idEnd = whenBegin++;
long when = RawParseUtils.parseLongBase10(raw, whenBegin, p);
boolean hasWhen = p.value != whenBegin;
if (hasTz && hasWhen) {
idEnd = whenBegin - 1;
} else {
// If either tz or when are non-numeric, mimic parsePersonIdent behavior and
// set them both to zero.
tz = 0;
when = 0;
if (hasTz && !hasWhen) {
// Only one trailing numeric field; assume User ID ends before this
// field, but discard its value.
idEnd = tzBegin - 1;
} else {
// No trailing numeric fields; User ID is whole raw value.
idEnd = raw.length;
}
}
String id = new String(raw, 0, idEnd, UTF_8);
return new PushCertificateIdent(str, id, when * 1000L, tz);
}
private final String raw;
private final String userId;
private final long when;
private final int tzOffset;
/**
* Construct a new identity from an OpenPGP User ID.
*
* @param userId
* OpenPGP User ID; any UTF-8 string.
* @param when
* local time.
* @param tzOffset
* timezone offset; see {@link #getTimeZoneOffset()}.
*/
public PushCertificateIdent(String userId, long when, int tzOffset) {
this.userId = userId;
this.when = when;
this.tzOffset = tzOffset;
StringBuilder sb = new StringBuilder(userId).append(' ').append(when / 1000)
.append(' ');
PersonIdent.appendTimezone(sb, tzOffset);
raw = sb.toString();
}
private PushCertificateIdent(String raw, String userId, long when,
int tzOffset) {
this.raw = raw;
this.userId = userId;
this.when = when;
this.tzOffset = tzOffset;
}
/**
* Get the raw string from which this identity was parsed.
* <p>
* If the string was constructed manually, a suitable canonical string is
* returned.
* <p>
* For the purposes of bytewise comparisons with other OpenPGP IDs, the string
* must be encoded as UTF-8.
*
* @return the raw string.
*/
public String getRaw() {
return raw;
}
/**
* Get the OpenPGP User ID, which may be any string.
*
* @return the OpenPGP User ID, which may be any string.
*/
public String getUserId() {
return userId;
}
/**
* Get the name portion of the User ID.
*
* @return the name portion of the User ID. If no email address would be
* parsed by {@link #getEmailAddress()}, returns the full User ID
* with spaces trimmed.
*/
public String getName() {
int nameEnd = userId.indexOf('<');
if (nameEnd < 0 || userId.indexOf('>', nameEnd) < 0) {
nameEnd = userId.length();
}
nameEnd--;
while (nameEnd >= 0 && userId.charAt(nameEnd) == ' ') {
nameEnd--;
}
int nameBegin = 0;
while (nameBegin < nameEnd && userId.charAt(nameBegin) == ' ') {
nameBegin++;
}
return userId.substring(nameBegin, nameEnd + 1);
}
/**
* Get the email portion of the User ID
*
* @return the email portion of the User ID, if one was successfully parsed
* from {@link #getUserId()}, or null.
*/
public String getEmailAddress() {
int emailBegin = userId.indexOf('<');
if (emailBegin < 0) {
return null;
}
int emailEnd = userId.indexOf('>', emailBegin);
if (emailEnd < 0) {
return null;
}
return userId.substring(emailBegin + 1, emailEnd);
}
/**
* Get the timestamp of the identity.
*
* @return the timestamp of the identity.
*/
public Date getWhen() {
return new Date(when);
}
/**
* Get this person's declared time zone
*
* @return this person's declared time zone; null if the timezone is
* unknown.
*/
public TimeZone getTimeZone() {
return PersonIdent.getTimeZone(tzOffset);
}
/**
* Get this person's declared time zone as minutes east of UTC.
*
* @return this person's declared time zone as minutes east of UTC. If the
* timezone is to the west of UTC it is negative.
*/
public int getTimeZoneOffset() {
return tzOffset;
}
/** {@inheritDoc} */
@Override
public boolean equals(Object o) {
return (o instanceof PushCertificateIdent)
&& raw.equals(((PushCertificateIdent) o).raw);
}
/** {@inheritDoc} */
@Override
public int hashCode() {
return raw.hashCode();
}
/** {@inheritDoc} */
@SuppressWarnings("nls")
@Override
public String toString() {
SimpleDateFormat fmt;
fmt = new SimpleDateFormat("EEE MMM d HH:mm:ss yyyy Z", Locale.US);
fmt.setTimeZone(getTimeZone());
return getClass().getSimpleName()
+ "[raw=\"" + raw + "\","
+ " userId=\"" + userId + "\","
+ " " + fmt.format(Long.valueOf(when)) + "]";
}
}