at

lib/common/certificate.go

@@ -55,6 +55,7 @@ func (certificate Certificate) Type() (cert_type int, err error) {
 	cert_len := len(certificate)
 	if cert_len < CERT_MIN_SIZE {
 		log.WithFields(log.Fields{
+			"at": "(Certificate) Type",
 			"certificate_bytes_length": cert_len,
 			"reason":                   "too short (len < CERT_MIN_SIZE)",
 		}).Error("invalid certificate")
@@ -80,6 +81,7 @@ func (certificate Certificate) Length() (length int, err error) {
 	inferred_len := length + CERT_MIN_SIZE
 	if inferred_len > cert_len {
 		log.WithFields(log.Fields{
+			"at": "(Certificate) Length",
 			"certificate_bytes_length": cert_len,
 			"certificate_length_field": length,
 			"expected_bytes_length":    inferred_len,
@@ -88,6 +90,7 @@ func (certificate Certificate) Length() (length int, err error) {
 		err = errors.New("certificate parsing warning: certificate data is shorter than specified by length")
 	} else if cert_len > inferred_len {
 		log.WithFields(log.Fields{
+			"at": "(Certificate) Length",
 			"certificate_bytes_length": cert_len,
 			"certificate_length_field": length,
 			"expected_bytes_length":    inferred_len,

lib/common/key_certificate.go

@@ -94,6 +94,7 @@ func (key_certificate KeyCertificate) SigningPublicKeyType() (signing_pubkey_typ
 	data_len := len(data)
 	if data_len < 2 {
 		log.WithFields(log.Fields{
+			"at":           "(KeyCertificate) SigningPublicKeyType",
 			"data_len":     data_len,
 			"required_len": 2,
 			"reason":       "not enough data",
@@ -117,6 +118,7 @@ func (key_certificate KeyCertificate) PublicKeyType() (pubkey_type int, err erro
 	data_len := len(data)
 	if data_len < 4 {
 		log.WithFields(log.Fields{
+			"at":           "(KeyCertificate) PublicKeyType",
 			"data_len":     data_len,
 			"required_len": 4,
 			"reason":       "not enough data",
@@ -140,6 +142,7 @@ func (key_certificate KeyCertificate) ConstructPublicKey(data []byte) (public_ke
 	data_len := len(data)
 	if data_len < KEYCERT_PUBKEY_SIZE {
 		log.WithFields(log.Fields{
+			"at":           "(KeyCertificate) ConstructPublicKey",
 			"data_len":     data_len,
 			"required_len": KEYCERT_PUBKEY_SIZE,
 			"reason":       "not enough data",
@@ -168,6 +171,7 @@ func (key_certificate KeyCertificate) ConstructSigningPublicKey(data []byte) (si
 	data_len := len(data)
 	if data_len < KEYCERT_SPK_SIZE {
 		log.WithFields(log.Fields{
+			"at":           "(KeyCertificate) ConstructSigningPublicKey",
 			"data_len":     data_len,
 			"required_len": KEYCERT_SPK_SIZE,
 			"reason":       "not enough data",

lib/common/keys_and_cert.go

@@ -94,6 +94,7 @@ func (keys_and_cert KeysAndCert) PublicKey() (key crypto.PublicKey, err error) {
 			copy(keys_and_cert[:KEYS_AND_CERT_PUBKEY_SIZE], elg_key[:])
 			key = elg_key
 			log.WithFields(log.Fields{
+				"at":        "(KeysAndCert) PublicKey",
 				"cert_type": cert_type,
 			}).Warn("unused certificate type observed")
 		}
@@ -149,6 +150,7 @@ func (keys_and_cert KeysAndCert) Certificate() (cert Certificate, err error) {
 	keys_cert_len := len(keys_and_cert)
 	if keys_cert_len < KEYS_AND_CERT_MIN_SIZE {
 		log.WithFields(log.Fields{
+			"at":           "(KeysAndCert) Certificate",
 			"data_len":     keys_cert_len,
 			"required_len": KEYS_AND_CERT_MIN_SIZE,
 			"reason":       "not enough data",
@@ -168,6 +170,7 @@ func ReadKeysAndCert(data []byte) (keys_and_cert KeysAndCert, remainder []byte,
 	data_len := len(data)
 	if data_len < KEYS_AND_CERT_MIN_SIZE {
 		log.WithFields(log.Fields{
+			"at":           "ReadKeysAndCert",
 			"data_len":     data_len,
 			"required_len": KEYS_AND_CERT_MIN_SIZE,
 			"reason":       "not enough data",

lib/common/lease_set.go

@@ -111,6 +111,7 @@ func (lease_set LeaseSet) PublicKey() (public_key crypto.ElgPublicKey, err error
 	remainder_len := len(remainder)
 	if remainder_len < LEASE_SET_PUBKEY_SIZE {
 		log.WithFields(log.Fields{
+			"at":           "(LeaseSet) PublicKey",
 			"data_len":     remainder_len,
 			"required_len": LEASE_SET_PUBKEY_SIZE,
 			"reason":       "not enough data",
@@ -144,6 +145,7 @@ func (lease_set LeaseSet) SigningKey() (signing_public_key crypto.SigningPublicK
 	lease_set_len := len(lease_set)
 	if lease_set_len < offset+LEASE_SET_SPK_SIZE {
 		log.WithFields(log.Fields{
+			"at":           "(LeaseSet) SigningKey",
 			"data_len":     lease_set_len,
 			"required_len": offset + LEASE_SET_SPK_SIZE,
 			"reason":       "not enough data",
@@ -190,6 +192,7 @@ func (lease_set LeaseSet) LeaseCount() (count int, err error) {
 	remainder_len := len(remainder)
 	if remainder_len < LEASE_SET_PUBKEY_SIZE+LEASE_SET_SPK_SIZE+1 {
 		log.WithFields(log.Fields{
+			"at":           "(LeaseSet) LeaseCount",
 			"data_len":     remainder_len,
 			"required_len": LEASE_SET_PUBKEY_SIZE + LEASE_SET_SPK_SIZE + 1,
 			"reason":       "not enough data",
@@ -220,6 +223,7 @@ func (lease_set LeaseSet) Leases() (leases []Lease, err error) {
 		lease_set_len := len(lease_set)
 		if lease_set_len < end {
 			log.WithFields(log.Fields{
+				"at":           "(LeaseSet) Leases",
 				"data_len":     lease_set_len,
 				"required_len": end,
 				"reason":       "some leases missing",
@@ -266,6 +270,7 @@ func (lease_set LeaseSet) Signature() (signature Signature, err error) {
 	lease_set_len := len(lease_set)
 	if lease_set_len < end {
 		log.WithFields(log.Fields{
+			"at":           "(LeaseSet) Signature",
 			"data_len":     lease_set_len,
 			"required_len": end,
 			"reason":       "not enough data",

lib/common/mapping.go

@@ -51,6 +51,7 @@ func (mapping Mapping) Values() (map_values MappingValues, errs []error) {
 	mapping_len := len(mapping)
 	if mapping_len > inferred_length {
 		log.WithFields(log.Fields{
+			"at": "(Mapping) Values",
 			"mappnig_bytes_length":  mapping_len,
 			"mapping_length_field":  length,
 			"expected_bytes_length": inferred_length,
@@ -59,6 +60,7 @@ func (mapping Mapping) Values() (map_values MappingValues, errs []error) {
 		errs = append(errs, errors.New("warning parsing mapping: data exists beyond length of mapping"))
 	} else if inferred_length > mapping_len {
 		log.WithFields(log.Fields{
+			"at": "(Mapping) Values",
 			"mappnig_bytes_length":  mapping_len,
 			"mapping_length_field":  length,
 			"expected_bytes_length": inferred_length,
@@ -80,6 +82,7 @@ func (mapping Mapping) Values() (map_values MappingValues, errs []error) {
 		}
 		if !beginsWith(remainder, 0x3d) {
 			log.WithFields(log.Fields{
+				"at":     "(Mapping) Values",
 				"reason": "expected =",
 			}).Warn("mapping format violation")
 			errs = append(errs, errors.New("mapping format violation, expected ="))
@@ -99,6 +102,7 @@ func (mapping Mapping) Values() (map_values MappingValues, errs []error) {
 		}
 		if !beginsWith(remainder, 0x3b) {
 			log.WithFields(log.Fields{
+				"at":     "(Mapping) Values",
 				"reason": "expected ;",
 			}).Warn("mapping format violation")
 			errs = append(errs, errors.New("mapping format violation, expected ;"))

lib/common/router_address.go

@@ -110,12 +110,14 @@ func (router_address RouterAddress) checkValid() (err error, exit bool) {
 	exit = false
 	if addr_len == 0 {
 		log.WithFields(log.Fields{
+			"at":     "(RouterAddress) checkValid",
 			"reason": "no data",
 		}).Error("invalid router address")
 		err = errors.New("error parsing RouterAddress: no data")
 		exit = true
 	} else if addr_len < ROUTER_ADDRESS_MIN_SIZE {
 		log.WithFields(log.Fields{
+			"at":     "(RouterAddress) checkValid",
 			"reason": "data too small (len < ROUTER_ADDRESS_MIN_SIZE)",
 		}).Warn("router address format warning")
 		err = errors.New("warning parsing RouterAddress: data too small")

lib/common/router_info.go

@@ -97,6 +97,7 @@ func (router_info RouterInfo) Published() (date Date, err error) {
 	remainder_len := len(remainder)
 	if remainder_len < 8 {
 		log.WithFields(log.Fields{
+			"at":           "(RouterInfo) Published",
 			"data_len":     remainder_len,
 			"required_len": 8,
 			"reason":       "not enough data",
@@ -116,6 +117,7 @@ func (router_info RouterInfo) RouterAddressCount() (count int, err error) {
 	remainder_len := len(remainder)
 	if remainder_len < 9 {
 		log.WithFields(log.Fields{
+			"at":           "(RouterInfo) RouterAddressCount",
 			"data_len":     remainder_len,
 			"required_len": 9,
 			"reason":       "not enough data",
@@ -136,6 +138,7 @@ func (router_info RouterInfo) RouterAddresses() (router_addresses []RouterAddres
 	remainder_len := len(remainder)
 	if remainder_len < 9 {
 		log.WithFields(log.Fields{
+			"at":           "(RouterInfo) RouterAddresses",
 			"data_len":     remainder_len,
 			"required_len": 9,
 			"reason":       "not enough data",

lib/common/string.go

@@ -24,6 +24,7 @@ type String []byte
 func (str String) Length() (length int, err error) {
 	if len(str) == 0 {
 		log.WithFields(log.Fields{
+			"at":     "(String) Length",
 			"reason": "no data",
 		}).Error("error parsing string")
 		err = errors.New("error parsing string: zero length")
@@ -34,6 +35,7 @@ func (str String) Length() (length int, err error) {
 	str_len := len(str)
 	if inferred_len > str_len {
 		log.WithFields(log.Fields{
+			"at": "(String) Length",
 			"string_bytes_length":   str_len,
 			"string_length_field":   length,
 			"expected_bytes_length": inferred_len,
@@ -42,6 +44,7 @@ func (str String) Length() (length int, err error) {
 		err = errors.New("string parsing warning: string data is shorter than specified by length")
 	} else if str_len > inferred_len {
 		log.WithFields(log.Fields{
+			"at": "(String) Length",
 			"string_bytes_length":   str_len,
 			"string_length_field":   length,
 			"expected_bytes_length": inferred_len,
@@ -81,6 +84,7 @@ func ToI2PString(data string) (str String, err error) {
 	data_len := len(data)
 	if data_len > STRING_MAX_SIZE {
 		log.WithFields(log.Fields{
+			"at":         "ToI2PString",
 			"string_len": data_len,
 			"max_len":    STRING_MAX_SIZE,
 			"reason":     "too much data",