( )⚙ D8368 manifest: start removing 40-byte hash restrictions from C code

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8368

manifest: start removing 40-byte hash restrictions from C code
ClosedPublic

Authored by durin42 on Apr 2 2020, 4:31 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG0b0e72b5d551: manifest: start removing 40-byte hash restrictions from C code

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

durin42 created this revision.Apr 2 2020, 4:31 PM
Alphare accepted this revision.Apr 14 2020, 4:48 AM
pulkit accepted this revision.Apr 14 2020, 2:56 PM
This revision is now accepted and ready to land.Apr 14 2020, 2:56 PM

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/manifest.c (37 lines)

Diff 20971

mercurial/cext/manifest.c

return (end) ? (Py_ssize_t)(end - l->start) : l->len; return (end) ? (Py_ssize_t)(end - l->start) : l->len;
} }
/* get the node value of a single line */ /* get the node value of a single line */
static PyObject *nodeof(line *l) static PyObject *nodeof(line *l)
{ {
char *s = l->start; char *s = l->start;
Py_ssize_t llen = pathlen(l); Py_ssize_t llen = pathlen(l);
Py_ssize_t hlen = l->len - llen - 2;
Py_ssize_t hlen_raw = 20;
PyObject *hash; PyObject *hash;
if (llen + 1 + 40 + 1 > l->len) { /* path '\0' hash '\n' */ if (llen + 1 + 40 + 1 > l->len) { /* path '\0' hash '\n' */
PyErr_SetString(PyExc_ValueError, "manifest line too short"); PyErr_SetString(PyExc_ValueError, "manifest line too short");
return NULL; return NULL;
} }
hash = unhexlify(s + llen + 1, 40); switch (hlen) {
case 40: /* sha1 */
case 41: /* sha1 with cruft for a merge */
break;
case 64: /* new hash */
case 65: /* new hash with cruft for a merge */
hlen_raw = 32;
break;
default:
PyErr_SetString(PyExc_ValueError, "invalid node length in manifest");
return NULL;
}
hash = unhexlify(s + llen + 1, hlen_raw * 2);
if (!hash) { if (!hash) {
return NULL; return NULL;
} }
if (l->hash_suffix != '\0') { if (l->hash_suffix != '\0') {
char newhash[21]; char newhash[33];
memcpy(newhash, PyBytes_AsString(hash), 20); memcpy(newhash, PyBytes_AsString(hash), hlen_raw);
Py_DECREF(hash); Py_DECREF(hash);
newhash[20] = l->hash_suffix; newhash[hlen_raw] = l->hash_suffix;
hash = PyBytes_FromStringAndSize(newhash, 21); hash = PyBytes_FromStringAndSize(newhash, hlen_raw+1);
} }
return hash; return hash;
} }
/* get the node hash and flags of a line as a tuple */ /* get the node hash and flags of a line as a tuple */
static PyObject *hashflags(line *l) static PyObject *hashflags(line *l)
{ {
char *s = l->start; char *s = l->start;
Py_ssize_t plen = pathlen(l); Py_ssize_t plen = pathlen(l);
PyObject *hash = nodeof(l); PyObject *hash = nodeof(l);
ssize_t hlen;
/* 40 for hash, 1 for null byte, 1 for newline */ Py_ssize_t hplen, flen;
Py_ssize_t hplen = plen + 42;
Py_ssize_t flen = l->len - hplen;
PyObject *flags; PyObject *flags;
PyObject *tup; PyObject *tup;
if (!hash) if (!hash)
return NULL; return NULL;
/* hash is either 20 or 21 bytes for an old hash, so we use a
ternary here to get the "real" hexlified sha length. */
hlen = PyBytes_GET_SIZE(hash) < 22 ? 40 : 64;
/* 1 for null byte, 1 for newline */
hplen = plen + hlen + 2;
flen = l->len - hplen;
flags = PyBytes_FromStringAndSize(s + hplen - 1, flen); flags = PyBytes_FromStringAndSize(s + hplen - 1, flen);
if (!flags) { if (!flags) {
Py_DECREF(hash); Py_DECREF(hash);
return NULL; return NULL;
} }
tup = PyTuple_Pack(2, hash, flags); tup = PyTuple_Pack(2, hash, flags);
Py_DECREF(flags); Py_DECREF(flags);
Py_DECREF(hash); Py_DECREF(hash);