org.eclipse.jgit/src/org/eclipse/jgit/transport/PushCertificateIdent.java - sop/jgit - Git at Google

 /*
  * Copyright (C) 2015, Google Inc.
  * and other copyright owners as documented in the project's IP log.
  *
  * This program and the accompanying materials are made available
  * under the terms of the Eclipse Distribution License v1.0 which
  * accompanies this distribution, is reproduced below, and is
  * available at http://www.eclipse.org/org/documents/edl-v10.php
  *
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or
  * without modification, are permitted provided that the following
  * conditions are met:
  *
  * - Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  *
  * - Redistributions in binary form must reproduce the above
  *   copyright notice, this list of conditions and the following
  *   disclaimer in the documentation and/or other materials provided
  *   with the distribution.
  *
  * - Neither the name of the Eclipse Foundation, Inc. nor the
  *   names of its contributors may be used to endorse or promote
  *   products derived from this software without specific prior
  *   written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 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 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 identity, never null.
 	 */
 	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;
 	}

 	/** @return the OpenPGP User ID, which may be any string. */
 	public String getUserId() {
 		return userId;
 	}

 	/**
 	 * @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);
 	}

 	/**
 	 * @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);
 	}

 	/** @return the timestamp of the identity. */
 	public Date getWhen() {
 		return new Date(when);
 	}

 	/**
 	 * @return this person's declared time zone; null if the timezone is unknown.
 	 */
 	public TimeZone getTimeZone() {
 		return PersonIdent.getTimeZone(tzOffset);
 	}

 	/**
 	 * @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;
 	}

 	@Override
 	public boolean equals(Object o) {
 		return (o instanceof PushCertificateIdent)
 			&& raw.equals(((PushCertificateIdent) o).raw);
 	}

 	@Override
 	public int hashCode() {
 		return raw.hashCode();
 	}

 	@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)) + "]";
 	}
 }
	/*
	* Copyright (C) 2015, Google Inc.
	* and other copyright owners as documented in the project's IP log.
	*
	* This program and the accompanying materials are made available
	* under the terms of the Eclipse Distribution License v1.0 which
	* accompanies this distribution, is reproduced below, and is
	* available at http://www.eclipse.org/org/documents/edl-v10.php
	*
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or
	* without modification, are permitted provided that the following
	* conditions are met:
	*
	* - Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* - Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	*
	* - Neither the name of the Eclipse Foundation, Inc. nor the
	* names of its contributors may be used to endorse or promote
	* products derived from this software without specific prior
	* written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
	* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	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 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 identity, never null.
	*/
	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;
	}

	/** @return the OpenPGP User ID, which may be any string. */
	public String getUserId() {
	return userId;
	}

	/**
	* @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);
	}

	/**
	* @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);
	}

	/** @return the timestamp of the identity. */
	public Date getWhen() {
	return new Date(when);
	}

	/**
	* @return this person's declared time zone; null if the timezone is unknown.
	*/
	public TimeZone getTimeZone() {
	return PersonIdent.getTimeZone(tzOffset);
	}

	/**
	* @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;
	}

	@Override
	public boolean equals(Object o) {
	return (o instanceof PushCertificateIdent)
	&& raw.equals(((PushCertificateIdent) o).raw);
	}

	@Override
	public int hashCode() {
	return raw.hashCode();
	}

	@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)) + "]";
	}
	}