{
char *kwlist[] = { "k", 0 };
char *k;
- int sz;
+ Py_ssize_t sz;
if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &k, &sz))
goto end;
static PyObject *gcmeth_encrypt(PyObject *me, PyObject *arg)
{
char *p;
- int sz;
+ Py_ssize_t sz;
PyObject *rc = 0;
if (!PyArg_ParseTuple(arg, "s#:encrypt", &p, &sz)) return (0);
static PyObject *gcmeth_decrypt(PyObject *me, PyObject *arg)
{
char *p;
- int sz;
+ Py_ssize_t sz;
PyObject *rc = 0;
if (!PyArg_ParseTuple(arg, "s#:decrypt", &p, &sz)) return (0);
static PyObject *gcmeth_setiv(PyObject *me, PyObject *arg)
{
char *p;
- int sz;
+ Py_ssize_t sz;
if (!PyArg_ParseTuple(arg, "s#:setiv", &p, &sz)) goto end;
if (!GC_CLASS(GCIPHER_C(me))->blksz) VALERR("not a block cipher mode");
static PyObject *ghmeth_hash(PyObject *me, PyObject *arg)
{
char *p;
- int sz;
+ Py_ssize_t sz;
if (!PyArg_ParseTuple(arg, "s#:hash", &p, &sz)) return (0);
GH_HASH(GHASH_H(me), p, sz);
RETURN_ME;
static PyObject *ghmeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
char *p; \
- int sz; \
+ Py_ssize_t sz; \
if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
if (sz > MASK##n) TYERR("string too long"); \
GH_HASHBUF##W(GHASH_H(me), p, sz); \
{
char *kwlist[] = { "k", 0 };
char *k;
- int sz;
+ Py_ssize_t sz;
if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &k, &sz))
goto end;
poly1305key_pyobj *pk = (poly1305key_pyobj *)ty;
poly1305hash_pyobj *ph;
char *m = 0;
- int sz;
+ Py_ssize_t sz;
if (!PyArg_ParseTupleAndKeywords(arg, kw, "|s#:new", kwlist, &m, &sz))
return (0);
char *kwlist[] = { "k", 0 };
poly1305key_pyobj *pk;
char *k;
- int sz;
+ Py_ssize_t sz;
if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &k, &sz))
goto end;
static PyObject *polymeth_hash(PyObject *me, PyObject *arg)
{
char *p;
- int sz;
+ Py_ssize_t sz;
if (!PyArg_ParseTuple(arg, "s#:hash", &p, &sz)) return (0);
poly1305_hash(P1305_CTX(me), p, sz);
RETURN_ME;
static PyObject *polymeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
char *p; \
- int sz; \
+ Py_ssize_t sz; \
octet b[SZ_##W]; \
if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
if (sz > MASK##n) TYERR("string too long"); \
{ \
dance##_ctx dance; \
char *k, *n; \
- int ksz, nsz; \
+ Py_ssize_t ksz, nsz; \
PyObject *rc; \
if (!PyArg_ParseTuple(arg, "s#s#:" #hdance "_prf", \
&k, &ksz, &n, &nsz)) \
{
char *kwlist[] = { "key", 0 };
char *k;
- int sz;
+ Py_ssize_t sz;
const prpinfo *prp = GCPRP_PRP(ty);
PyObject *me;
static PyObject *gpmeth_encrypt(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
PyObject *rc = 0;
if (!PyArg_ParseTuple(arg, "s#:encrypt", &p, &n)) goto end;
static PyObject *gpmeth_decrypt(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
PyObject *rc = 0;
if (!PyArg_ParseTuple(arg, "s#:decrypt", &p, &n)) goto end;
static PyObject *rbuf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
char *p, *q;
- int n;
+ Py_ssize_t n;
buf_pyobj *me = 0;
static char *kwlist[] = { "data", 0 };
static PyObject *wbmeth_put(PyObject *me, PyObject *arg)
{
void *p;
- int n;
+ Py_ssize_t n;
if (!PyArg_ParseTuple(arg, "s#:put", &p, &n)) return (0);
ensure(me, n);
buf_put(BUF_B(me), p, n); assert(BOK(BUF_B(m)));
static PyObject *wbmeth_putblk##w(PyObject *me, PyObject *arg) \
{ \
char *p; \
- int sz; \
+ Py_ssize_t sz; \
if (!PyArg_ParseTuple(arg, "s#:putblk" #w, &p, &sz)) return (0); \
ensure(me, sz + SZ_##n); \
buf_putmem##w(BUF_B(me), p, sz); assert(BOK(BUF_B(me))); \
PyObject *arg, PyObject *kw)
{
const char *p;
- int n;
+ Py_ssize_t n;
static char *kwlist[] = { "data", 0 };
if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &p, &n))
return (0);
/*----- Header files ------------------------------------------------------*/
+#define PY_SSIZE_T_CLEAN
+
#include <Python.h>
#include <longintrepr.h>
#include <structmember.h>
static PyObject *meth__ECPtCurve_fromraw(PyObject *me, PyObject *arg)
{
char *p;
- int len;
+ Py_ssize_t len;
buf b;
PyObject *rc = 0;
ec_curve *cc;
PyObject *arg, PyObject *kw)
{
char *p;
- int len;
+ Py_ssize_t len;
buf b;
PyObject *rc = 0;
ec_curve *cc;
{
buf b;
char *p;
- int sz;
+ Py_ssize_t sz;
PyObject *rc = 0;
ec pp = EC_INIT;
unsigned steps = 0;
dsa_seed ds;
char *k;
- int ksz;
+ Py_ssize_t ksz;
pgev evt = { 0 };
char *kwlist[] =
{ "class", "pbits", "qbits", "seed", "event", "nsteps", 0 };
{
buf b;
char *p;
- int n;
+ Py_ssize_t n;
group *g;
ge *x = 0;
{
buf b;
char *p;
- int n;
+ Py_ssize_t n;
group *g;
ge *x = 0;
{
mptext_stringctx sc;
char *p;
- int n;
+ Py_ssize_t n;
group *g;
ge *x = 0;
if (G_READ(g, x, &mptext_stringops, &sc))
VALERR("bad group element string");
return (Py_BuildValue("(Ns#)", ge_pywrap(me, x),
- sc.buf, (int)(sc.lim - sc.buf)));
+ sc.buf, (Py_ssize_t)(sc.lim - sc.buf)));
end:
if (x) G_DESTROY(g, x);
return (0);
static PyObject *kdmeth_lock(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
PyObject *rc = 0;
key_data *kd;
static PyObject *meth__KeyData_decode(PyObject *me, PyObject *arg)
{
const char *p;
- int n;
+ Py_ssize_t n;
key_data *kd;
PyObject *rc = 0;
PyObject *arg, PyObject *kw)
{
char *p;
- int n;
+ Py_ssize_t n;
unsigned f = 0;
keydata_pyobj *me = 0;
static char *kwlist[] = { "key", "flags", 0 };
PyObject *arg, PyObject *kw)
{
char *p;
- int n;
+ Py_ssize_t n;
unsigned f = 0;
keydata_pyobj *me = 0;
static char *kwlist[] = { "key", "flags", 0 };
static PyObject *kdemeth_lock(PyObject *me, PyObject *arg)
{
char *hunoz;
- int hukairz;
+ Py_ssize_t hukairz;
if (!PyArg_ParseTuple(arg, "s#:lock", &hunoz, &hukairz)) goto end;
KEYERR(KERR_WRONGTYPE);
end:
static PyObject *kdemeth_unlock(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
int err;
PyObject *rc = 0;
key_data *kd;
}
key_incref(*kd);
rc = Py_BuildValue("(s#NN)",
- d.buf, d.len,
+ d.buf, (Py_ssize_t)d.len,
key_pywrap(me, k),
keydata_pywrap(okd));
end:
{ \
buf b; \
char *p; \
- int sz; \
+ Py_ssize_t sz; \
PyObject *rc = 0; \
mp *x; \
\
{
int r = 0;
char *p;
- int len;
+ Py_ssize_t len;
PyObject *z = 0;
mp *zz;
mptext_stringctx sc;
sc.buf = p; sc.lim = p + len;
if ((zz = mp_read(MP_NEW, r, &mptext_stringops, &sc)) == 0)
VALERR("bad integer");
- z = Py_BuildValue("(Ns#)", mp_pywrap(zz), sc.buf, (int)(sc.lim - sc.buf));
+ z = Py_BuildValue("(Ns#)", mp_pywrap(zz),
+ sc.buf, (Py_ssize_t)(sc.lim - sc.buf));
end:
return (z);
}
static PyObject *meth__##py##_##name(PyObject *me, PyObject *arg) \
{ \
char *p; \
- int len; \
+ Py_ssize_t len; \
if (!PyArg_ParseTuple(arg, "Os#:" #name, &me, &p, &len)) return (0); \
return (pre##_pywrap(mp_##name(MP_NEW, p, len))); \
}
{
int r = 0;
char *p;
- int len;
+ Py_ssize_t len;
PyObject *z = 0;
mp *zz;
mptext_stringctx sc;
if (zz) MP_DROP(zz);
VALERR("bad binary polynomial");
}
- z = Py_BuildValue("(Ns#)", gf_pywrap(zz), sc.buf, (int)(sc.lim - sc.buf));
+ z = Py_BuildValue("(Ns#)", gf_pywrap(zz),
+ sc.buf, (Py_ssize_t)(sc.lim - sc.buf));
end:
return (z);
}
{
gdsa_sig s = GDSA_SIG_INIT;
char *p;
- int n;
+ Py_ssize_t n;
mp *k = 0;
PyObject *rc = 0;
char *kwlist[] = { "msg", "k", 0 };
static PyObject *dsameth_verify(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
gdsa_sig s = GDSA_SIG_INIT;
PyObject *rc = 0;
{
gkcdsa_sig s = GKCDSA_SIG_INIT;
char *p;
- int n;
+ Py_ssize_t n;
mp *k = 0;
PyObject *r = 0, *rc = 0;
char *kwlist[] = { "msg", "k", 0 };
static PyObject *kcdsameth_verify(PyObject *me, PyObject *arg)
{
char *p;
- int n, rn;
+ Py_ssize_t n, rn;
gkcdsa_sig s = GKCDSA_SIG_INIT;
PyObject *rc = 0;
{
pkcs1 p1;
char *m, *ep;
- int msz, epsz;
+ Py_ssize_t msz, epsz;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
{
pkcs1 p1;
char *ep;
- int epsz;
+ Py_ssize_t epsz;
unsigned long nbits;
int n;
PyObject *rc = 0;
{
pkcs1 p1;
char *m, *ep;
- int msz, epsz;
+ Py_ssize_t msz, epsz;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
{
pkcs1 p1;
char *ep;
- int epsz;
+ Py_ssize_t epsz;
unsigned long nbits;
int n;
PyObject *hukairz;
{
oaep o;
char *m, *ep;
- int msz, epsz;
+ Py_ssize_t msz, epsz;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
{
oaep o;
char *ep;
- int epsz;
+ Py_ssize_t epsz;
unsigned long nbits;
int n;
PyObject *rc = 0;
{
pss p;
char *m;
- int msz;
+ Py_ssize_t msz;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
{
pss p;
char *m;
- int msz;
+ Py_ssize_t msz;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
static PyObject *grmeth_seedblock(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
grand *r = GRAND_R(me);
if (!PyArg_ParseTuple(arg, "s#:seedblock", &p, &n) ||
checkop(r, GRAND_SEEDBLOCK, "seedblock"))
{
grand *r = GRAND_R(me);
char *p, *q;
- int sz;
+ Py_ssize_t sz;
PyObject *rc;
if (!PyArg_ParseTuple(arg, "s#:mask", &p, &sz)) return (0);
static PyObject *trmeth_add(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
- char *p; int n; unsigned goodbits;
+ char *p; Py_ssize_t n; unsigned goodbits;
if (!PyArg_ParseTuple(arg, "s#O&:add", &p, &n, convuint, &goodbits))
return (0);
r->ops->misc(r, RAND_ADD, p, (size_t)n, goodbits);
static PyObject *trmeth_key(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
- char *p; int n;
+ char *p; Py_ssize_t n;
if (!PyArg_ParseTuple(arg, "s#:key", &p, &n)) return (0);
r->ops->misc(r, RAND_KEY, p, (size_t)n);
RETURN_ME;
const gccrand_info *info = GCCRAND_INFO(ty);
static char *kwlist[] = { "key", 0 };
char *k;
- int n;
+ Py_ssize_t n;
if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &k, &n))
goto end;
uint32 i = 0;
static char *kwlist[] = { "key", "i", 0 };
char *k;
- int n;
+ Py_ssize_t n;
if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#O&:new", kwlist,
&k, &n, convu32, &i))
const gccrand_info *info = GCCRAND_INFO(ty);
static char *kwlist[] = { "key", "nonce", 0 };
char *k, *n;
- int ksz, nsz;
+ Py_ssize_t ksz, nsz;
if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#s#:new", kwlist,
&k, &ksz, &n, &nsz))
PyObject *arg, PyObject *kw)
{
char *p;
- int n;
+ Py_ssize_t n;
unsigned t;
grand *r = &rand_global;
gfshare_pyobj *s;
{
unsigned i;
char *p;
- int n;
+ Py_ssize_t n;
if (!PyArg_ParseTuple(arg, "O&s#:add", convuint, &i, &p, &n)) goto end;
if (i > 254) VALERR("index must be < 255");
if (n != GFSHARE_S(me)->sz) VALERR("bad share size");