comparison mercurial/cext/manifest.c @ 47043:12450fbea288

manifests: push down expected node length into the parser

This strictly enforces the node length in the manifest lines according
to what the repository expects. One test case moves large hash testing
into the non-treemanifest part as treemanifests don't provide an
interface for overriding just the node length for now.

Differential Revision: https://phab.mercurial-scm.org/D10533

47042:c5e1cc0b4c77

} line;

typedef struct {
	PyObject_HEAD
	PyObject *pydata;
	line *lines;
	int numlines; /* number of line entries */
	int livelines; /* number of non-deleted lines */
	int maxlines; /* allocated number of lines */
	bool dirty;

	const char *end = memchr(l->start, '\0', l->len);
	return (end) ? (Py_ssize_t)(end - l->start) : l->len;
}

/* get the node value of a single line */
static PyObject *nodeof(line *l, char *flag)
{
	char *s = l->start;
	Py_ssize_t llen = pathlen(l);
	Py_ssize_t hlen = l->len - llen - 2;
	Py_ssize_t hlen_raw;
	PyObject *hash;
	if (llen + 1 + 40 + 1 > l->len) { /* path '\0' hash '\n' */
		PyErr_SetString(PyExc_ValueError, "manifest line too short");
		return NULL;
	}

	default:
		*flag = '\0';
		break;
	}

	switch (hlen) {
	case 40: /* sha1 */
		hlen_raw = 20;
		break;
	case 64: /* new hash */
		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) {
		return NULL;
	}
	if (l->hash_suffix != '\0') {
		char newhash[33];
		memcpy(newhash, PyBytes_AsString(hash), hlen_raw);
		Py_DECREF(hash);
		newhash[hlen_raw] = l->hash_suffix;
		hash = PyBytes_FromStringAndSize(newhash, hlen_raw+1);
	}
	return hash;
}

/* get the node hash and flags of a line as a tuple */
static PyObject *hashflags(line *l)
{
	char flag;
	PyObject *hash = nodeof(l, &flag);
	PyObject *flags;
	PyObject *tup;

	if (!hash)
		return NULL;

}

static int lazymanifest_init(lazymanifest *self, PyObject *args)
{
	char *data;
	Py_ssize_t len;
	int err, ret;
	PyObject *pydata;

	lazymanifest_init_early(self);
	if (!PyArg_ParseTuple(args, "S", &pydata)) {
		return -1;
	}
	err = PyBytes_AsStringAndSize(pydata, &data, &len);

	self->dirty = false;
	if (err == -1)
		return -1;
	self->pydata = pydata;
	Py_INCREF(self->pydata);
	Py_BEGIN_ALLOW_THREADS

	return self->m->lines + self->pos;
}

static PyObject *lmiter_iterentriesnext(PyObject *o)
{
	Py_ssize_t pl;
	line *l;
	char flag;
	PyObject *ret = NULL, *path = NULL, *hash = NULL, *flags = NULL;
	l = lmiter_nextline((lmIter *)o);
	if (!l) {
		goto done;
	}
	pl = pathlen(l);
	path = PyBytes_FromStringAndSize(l->start, pl);
	hash = nodeof(l, &flag);
	if (!path || !hash) {
		goto done;
	}
	flags = PyBytes_FromStringAndSize(&flag, flag ? 1 : 0);
	if (!flags) {

		      &linecmp);
	if (!hit || hit->deleted) {
		PyErr_Format(PyExc_KeyError, "No such manifest entry.");
		return NULL;
	}
	return hashflags(hit);
}

static int lazymanifest_delitem(lazymanifest *self, PyObject *key)
{
	line needle;

	}

	pyhash = PyTuple_GetItem(value, 0);
	if (!PyBytes_Check(pyhash)) {
		PyErr_Format(PyExc_TypeError,
			     "node must be a 20 or 32 bytes string");
		return -1;
	}
	hlen = PyBytes_Size(pyhash);
	if (hlen != 20 && hlen != 32) {
		PyErr_Format(PyExc_TypeError,
			     "node must be a 20 or 32 bytes string");
		return -1;
	}
	hash = PyBytes_AsString(pyhash);

	pyflags = PyTuple_GetItem(value, 1);

	copy = PyObject_New(lazymanifest, &lazymanifestType);
	if (!copy) {
		goto nomem;
	}
	lazymanifest_init_early(copy);
	copy->numlines = self->numlines;
	copy->livelines = self->livelines;
	copy->dirty = false;
	copy->lines = malloc(self->maxlines *sizeof(line));
	if (!copy->lines) {

	copy = PyObject_New(lazymanifest, &lazymanifestType);
	if (!copy) {
		goto nomem;
	}
	lazymanifest_init_early(copy);
	copy->dirty = true;
	copy->lines = malloc(self->maxlines * sizeof(line));
	if (!copy->lines) {
		goto nomem;
	}

			PyBytes_FromString(left->start) :
			PyBytes_FromString(right->start);
		if (!key)
			goto nomem;
		if (result < 0) {
			PyObject *l = hashflags(left);
			if (!l) {
				goto nomem;
			}
			outer = PyTuple_Pack(2, l, emptyTup);
			Py_DECREF(l);

			}
			PyDict_SetItem(ret, key, outer);
			Py_DECREF(outer);
			sneedle++;
		} else if (result > 0) {
			PyObject *r = hashflags(right);
			if (!r) {
				goto nomem;
			}
			outer = PyTuple_Pack(2, emptyTup, r);
			Py_DECREF(r);

		} else {
			/* file exists in both manifests */
			if (left->len != right->len
			    || memcmp(left->start, right->start, left->len)
			    || left->hash_suffix != right->hash_suffix) {
				PyObject *l = hashflags(left);
				PyObject *r;
				if (!l) {
					goto nomem;
				}
				r = hashflags(right);
				if (!r) {
					Py_DECREF(l);
					goto nomem;
				}
				outer = PyTuple_Pack(2, l, r);

47043:12450fbea288

} line;

typedef struct {
	PyObject_HEAD
	PyObject *pydata;
	Py_ssize_t nodelen;
	line *lines;
	int numlines; /* number of line entries */
	int livelines; /* number of non-deleted lines */
	int maxlines; /* allocated number of lines */
	bool dirty;

	const char *end = memchr(l->start, '\0', l->len);
	return (end) ? (Py_ssize_t)(end - l->start) : l->len;
}

/* get the node value of a single line */
static PyObject *nodeof(Py_ssize_t nodelen, line *l, char *flag)
{
	char *s = l->start;
	Py_ssize_t llen = pathlen(l);
	Py_ssize_t hlen = l->len - llen - 2;
	PyObject *hash;
	if (llen + 1 + 40 + 1 > l->len) { /* path '\0' hash '\n' */
		PyErr_SetString(PyExc_ValueError, "manifest line too short");
		return NULL;
	}

	default:
		*flag = '\0';
		break;
	}

	if (hlen != 2 * nodelen) {
		PyErr_SetString(PyExc_ValueError, "invalid node length in manifest");
		return NULL;
	}
	hash = unhexlify(s + llen + 1, nodelen * 2);
	if (!hash) {
		return NULL;
	}
	if (l->hash_suffix != '\0') {
		char newhash[33];
		memcpy(newhash, PyBytes_AsString(hash), nodelen);
		Py_DECREF(hash);
		newhash[nodelen] = l->hash_suffix;
		hash = PyBytes_FromStringAndSize(newhash, nodelen + 1);
	}
	return hash;
}

/* get the node hash and flags of a line as a tuple */
static PyObject *hashflags(Py_ssize_t nodelen, line *l)
{
	char flag;
	PyObject *hash = nodeof(nodelen, l, &flag);
	PyObject *flags;
	PyObject *tup;

	if (!hash)
		return NULL;

}

static int lazymanifest_init(lazymanifest *self, PyObject *args)
{
	char *data;
	Py_ssize_t nodelen, len;
	int err, ret;
	PyObject *pydata;

	lazymanifest_init_early(self);
	if (!PyArg_ParseTuple(args, "nS", &nodelen, &pydata)) {
		return -1;
	}
	if (nodelen != 20 && nodelen != 32) {
		/* See fixed buffer in nodeof */
		PyErr_Format(PyExc_ValueError, "Unsupported node length");
		return -1;
	}
	self->nodelen = nodelen;
	self->dirty = false;

	err = PyBytes_AsStringAndSize(pydata, &data, &len);
	if (err == -1)
		return -1;
	self->pydata = pydata;
	Py_INCREF(self->pydata);
	Py_BEGIN_ALLOW_THREADS

	return self->m->lines + self->pos;
}

static PyObject *lmiter_iterentriesnext(PyObject *o)
{
	lmIter *self = (lmIter *)o;
	Py_ssize_t pl;
	line *l;
	char flag;
	PyObject *ret = NULL, *path = NULL, *hash = NULL, *flags = NULL;
	l = lmiter_nextline(self);
	if (!l) {
		goto done;
	}
	pl = pathlen(l);
	path = PyBytes_FromStringAndSize(l->start, pl);
	hash = nodeof(self->m->nodelen, l, &flag);
	if (!path || !hash) {
		goto done;
	}
	flags = PyBytes_FromStringAndSize(&flag, flag ? 1 : 0);
	if (!flags) {

		      &linecmp);
	if (!hit || hit->deleted) {
		PyErr_Format(PyExc_KeyError, "No such manifest entry.");
		return NULL;
	}
	return hashflags(self->nodelen, hit);
}

static int lazymanifest_delitem(lazymanifest *self, PyObject *key)
{
	line needle;

	}

	pyhash = PyTuple_GetItem(value, 0);
	if (!PyBytes_Check(pyhash)) {
		PyErr_Format(PyExc_TypeError,
			     "node must be a %zi bytes string", self->nodelen);
		return -1;
	}
	hlen = PyBytes_Size(pyhash);
	if (hlen != self->nodelen) {
		PyErr_Format(PyExc_TypeError,
			     "node must be a %zi bytes string", self->nodelen);
		return -1;
	}
	hash = PyBytes_AsString(pyhash);

	pyflags = PyTuple_GetItem(value, 1);

	copy = PyObject_New(lazymanifest, &lazymanifestType);
	if (!copy) {
		goto nomem;
	}
	lazymanifest_init_early(copy);
	copy->nodelen = self->nodelen;
	copy->numlines = self->numlines;
	copy->livelines = self->livelines;
	copy->dirty = false;
	copy->lines = malloc(self->maxlines *sizeof(line));
	if (!copy->lines) {

	copy = PyObject_New(lazymanifest, &lazymanifestType);
	if (!copy) {
		goto nomem;
	}
	lazymanifest_init_early(copy);
	copy->nodelen = self->nodelen;
	copy->dirty = true;
	copy->lines = malloc(self->maxlines * sizeof(line));
	if (!copy->lines) {
		goto nomem;
	}

			PyBytes_FromString(left->start) :
			PyBytes_FromString(right->start);
		if (!key)
			goto nomem;
		if (result < 0) {
			PyObject *l = hashflags(self->nodelen, left);
			if (!l) {
				goto nomem;
			}
			outer = PyTuple_Pack(2, l, emptyTup);
			Py_DECREF(l);

			}
			PyDict_SetItem(ret, key, outer);
			Py_DECREF(outer);
			sneedle++;
		} else if (result > 0) {
			PyObject *r = hashflags(self->nodelen, right);
			if (!r) {
				goto nomem;
			}
			outer = PyTuple_Pack(2, emptyTup, r);
			Py_DECREF(r);

		} else {
			/* file exists in both manifests */
			if (left->len != right->len
			    || memcmp(left->start, right->start, left->len)
			    || left->hash_suffix != right->hash_suffix) {
				PyObject *l = hashflags(self->nodelen, left);
				PyObject *r;
				if (!l) {
					goto nomem;
				}
				r = hashflags(self->nodelen, right);
				if (!r) {
					Py_DECREF(l);
					goto nomem;
				}
				outer = PyTuple_Pack(2, l, r);