On Sat Feb 24 19:29:03 2018, MSHELOR wrote:
Show quoted text> On Mon Feb 19 18:00:04 2018, RANDIR wrote:
> > While building this module under 64-bit version of MS VS2017, I get
> > the following build warnings:
> >
> > SHA.xs(155): warning C4267: 'function': conversion from 'size_t' to
> > 'unsigned long', possible loss of data
> > SHA.xs(206): warning C4267: 'function': conversion from 'size_t' to
> > 'unsigned int', possible loss of data
> > SHA.xs(215): warning C4267: 'function': conversion from 'size_t' to
> > 'unsigned long', possible loss of data
> > SHA.xs(264): warning C4267: 'function': conversion from 'size_t' to
> > 'unsigned long', possible loss of data
> > SHA.xs(359): warning C4244: '=': conversion from '__int64' to 'int',
> > possible loss of data
> > SHA.xs(377): warning C4244: '=': conversion from '__int64' to 'int',
> > possible loss of data
>
> Yes, that's understandable. Thanks for letting me know.
>
> I've addressed these warnings in draft version 6.02 by the use of
> explicit typecasting, which appears to be the only reliable way given
> that perlapio has a history of changing return-value types (e.g.
> PerlIO_read went from 'int' to 'SSize_t').
>
> Mark
Here's the updated draft version of SHA.xs if you want to confirm whether it compiles under VS without warnings.
Mark
#define PERL_NO_GET_CONTEXT
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#ifdef SvPVbyte
#if PERL_REVISION == 5 && PERL_VERSION < 8
#undef SvPVbyte
#define SvPVbyte(sv, lp) \
(sv_utf8_downgrade((sv), 0), SvPV((sv), (lp)))
#endif
#else
#define SvPVbyte SvPV
#endif
#ifndef dTHX
#define pTHX_
#define aTHX_
#endif
#ifndef PerlIO
#define PerlIO FILE
#define PerlIO_read(f, buf, count) fread(buf, 1, count, f)
#endif
#ifndef sv_derived_from
#include "src/sdf.c"
#endif
#ifndef Newx
#define Newx(ptr, num, type) New(0, ptr, num, type)
#define Newxz(ptr, num, type) Newz(0, ptr, num, type)
#endif
#include "src/sha.c"
static const int ix2alg[] =
{1,1,1,224,224,224,256,256,256,384,384,384,512,512,512,
512224,512224,512224,512256,512256,512256};
#ifndef INT2PTR
#define INT2PTR(p, i) (p) (i)
#endif
#define MAX_WRITE_SIZE 16384
#define IO_BUFFER_SIZE 4096
static SHA *getSHA(pTHX_ SV *self)
{
if (!sv_isobject(self) || !sv_derived_from(self, "Digest::SHA"))
return(NULL);
return INT2PTR(SHA *, SvIV(SvRV(self)));
}
MODULE = Digest::SHA PACKAGE = Digest::SHA
PROTOTYPES: ENABLE
int
shainit(s, alg)
SHA * s
int alg
void
sharewind(s)
SHA * s
unsigned long
shawrite(bitstr, bitcnt, s)
unsigned char * bitstr
unsigned long bitcnt
SHA * s
SV *
newSHA(classname, alg)
char * classname
int alg
PREINIT:
SHA *state;
CODE:
Newxz(state, 1, SHA);
if (!shainit(state, alg)) {
Safefree(state);
XSRETURN_UNDEF;
}
RETVAL = newSV(0);
sv_setref_pv(RETVAL, classname, (void *) state);
SvREADONLY_on(SvRV(RETVAL));
OUTPUT:
RETVAL
SV *
clone(self)
SV * self
PREINIT:
SHA *state;
SHA *clone;
CODE:
if ((state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
Newx(clone, 1, SHA);
RETVAL = newSV(0);
sv_setref_pv(RETVAL, sv_reftype(SvRV(self), 1), (void *) clone);
SvREADONLY_on(SvRV(RETVAL));
Copy(state, clone, 1, SHA);
OUTPUT:
RETVAL
void
DESTROY(s)
SHA * s
CODE:
Safefree(s);
SV *
sha1(...)
ALIAS:
Digest::SHA::sha1 = 0
Digest::SHA::sha1_hex = 1
Digest::SHA::sha1_base64 = 2
Digest::SHA::sha224 = 3
Digest::SHA::sha224_hex = 4
Digest::SHA::sha224_base64 = 5
Digest::SHA::sha256 = 6
Digest::SHA::sha256_hex = 7
Digest::SHA::sha256_base64 = 8
Digest::SHA::sha384 = 9
Digest::SHA::sha384_hex = 10
Digest::SHA::sha384_base64 = 11
Digest::SHA::sha512 = 12
Digest::SHA::sha512_hex = 13
Digest::SHA::sha512_base64 = 14
Digest::SHA::sha512224 = 15
Digest::SHA::sha512224_hex = 16
Digest::SHA::sha512224_base64 = 17
Digest::SHA::sha512256 = 18
Digest::SHA::sha512256_hex = 19
Digest::SHA::sha512256_base64 = 20
PREINIT:
int i;
UCHR *data;
STRLEN len;
SHA sha;
char *result;
CODE:
if (!shainit(&sha, ix2alg[ix]))
XSRETURN_UNDEF;
for (i = 0; i < items; i++) {
data = (UCHR *) (SvPVbyte(ST(i), len));
while (len > MAX_WRITE_SIZE) {
shawrite(data, MAX_WRITE_SIZE << 3, &sha);
data += MAX_WRITE_SIZE;
len -= MAX_WRITE_SIZE;
}
shawrite(data, (ULNG) len << 3, &sha);
}
shafinish(&sha);
len = 0;
if (ix % 3 == 0) {
result = (char *) shadigest(&sha);
len = sha.digestlen;
}
else if (ix % 3 == 1)
result = shahex(&sha);
else
result = shabase64(&sha);
RETVAL = newSVpv(result, len);
OUTPUT:
RETVAL
SV *
hmac_sha1(...)
ALIAS:
Digest::SHA::hmac_sha1 = 0
Digest::SHA::hmac_sha1_hex = 1
Digest::SHA::hmac_sha1_base64 = 2
Digest::SHA::hmac_sha224 = 3
Digest::SHA::hmac_sha224_hex = 4
Digest::SHA::hmac_sha224_base64 = 5
Digest::SHA::hmac_sha256 = 6
Digest::SHA::hmac_sha256_hex = 7
Digest::SHA::hmac_sha256_base64 = 8
Digest::SHA::hmac_sha384 = 9
Digest::SHA::hmac_sha384_hex = 10
Digest::SHA::hmac_sha384_base64 = 11
Digest::SHA::hmac_sha512 = 12
Digest::SHA::hmac_sha512_hex = 13
Digest::SHA::hmac_sha512_base64 = 14
Digest::SHA::hmac_sha512224 = 15
Digest::SHA::hmac_sha512224_hex = 16
Digest::SHA::hmac_sha512224_base64 = 17
Digest::SHA::hmac_sha512256 = 18
Digest::SHA::hmac_sha512256_hex = 19
Digest::SHA::hmac_sha512256_base64 = 20
PREINIT:
int i;
UCHR *key = (UCHR *) "";
UCHR *data;
STRLEN len = 0;
HMAC hmac;
char *result;
CODE:
if (items > 0) {
key = (UCHR *) (SvPVbyte(ST(items-1), len));
}
if (hmacinit(&hmac, ix2alg[ix], key, (UINT) len) == NULL)
XSRETURN_UNDEF;
for (i = 0; i < items - 1; i++) {
data = (UCHR *) (SvPVbyte(ST(i), len));
while (len > MAX_WRITE_SIZE) {
hmacwrite(data, MAX_WRITE_SIZE << 3, &hmac);
data += MAX_WRITE_SIZE;
len -= MAX_WRITE_SIZE;
}
hmacwrite(data, (ULNG) len << 3, &hmac);
}
hmacfinish(&hmac);
len = 0;
if (ix % 3 == 0) {
result = (char *) hmacdigest(&hmac);
len = hmac.digestlen;
}
else if (ix % 3 == 1)
result = hmachex(&hmac);
else
result = hmacbase64(&hmac);
RETVAL = newSVpv(result, len);
OUTPUT:
RETVAL
int
hashsize(self)
SV * self
ALIAS:
Digest::SHA::hashsize = 0
Digest::SHA::algorithm = 1
PREINIT:
SHA *state;
CODE:
if ((state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
RETVAL = ix ? state->alg : (int) (state->digestlen << 3);
OUTPUT:
RETVAL
void
add(self, ...)
SV * self
PREINIT:
int i;
UCHR *data;
STRLEN len;
SHA *state;
PPCODE:
if ((state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
for (i = 1; i < items; i++) {
data = (UCHR *) (SvPVbyte(ST(i), len));
while (len > MAX_WRITE_SIZE) {
shawrite(data, MAX_WRITE_SIZE << 3, state);
data += MAX_WRITE_SIZE;
len -= MAX_WRITE_SIZE;
}
shawrite(data, (ULNG) len << 3, state);
}
XSRETURN(1);
SV *
digest(self)
SV * self
ALIAS:
Digest::SHA::digest = 0
Digest::SHA::hexdigest = 1
Digest::SHA::b64digest = 2
PREINIT:
STRLEN len;
SHA *state;
char *result;
CODE:
if ((state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
shafinish(state);
len = 0;
if (ix == 0) {
result = (char *) shadigest(state);
len = state->digestlen;
}
else if (ix == 1)
result = shahex(state);
else
result = shabase64(state);
RETVAL = newSVpv(result, len);
sharewind(state);
OUTPUT:
RETVAL
SV *
_getstate(self)
SV * self
PREINIT:
SHA *state;
UCHR buf[256];
UCHR *ptr = buf;
CODE:
if ((state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
Copy(digcpy(state), ptr, state->alg <= SHA256 ? 32 : 64, UCHR);
ptr += state->alg <= SHA256 ? 32 : 64;
Copy(state->block, ptr, state->alg <= SHA256 ? 64 : 128, UCHR);
ptr += state->alg <= SHA256 ? 64 : 128;
ptr = w32mem(ptr, state->blockcnt);
ptr = w32mem(ptr, state->lenhh);
ptr = w32mem(ptr, state->lenhl);
ptr = w32mem(ptr, state->lenlh);
ptr = w32mem(ptr, state->lenll);
RETVAL = newSVpv((char *) buf, (STRLEN) (ptr - buf));
OUTPUT:
RETVAL
void
_putstate(self, packed_state)
SV * self
SV * packed_state
PREINIT:
UINT bc;
STRLEN len;
SHA *state;
UCHR *data;
PPCODE:
if ((state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
data = (UCHR *) SvPV(packed_state, len);
if (len != (state->alg <= SHA256 ? 116U : 212U))
XSRETURN_UNDEF;
data = statecpy(state, data);
Copy(data, state->block, state->blocksize >> 3, UCHR);
data += (state->blocksize >> 3);
bc = memw32(data), data += 4;
if (bc >= (state->alg <= SHA256 ? 512U : 1024U))
XSRETURN_UNDEF;
state->blockcnt = bc;
state->lenhh = memw32(data), data += 4;
state->lenhl = memw32(data), data += 4;
state->lenlh = memw32(data), data += 4;
state->lenll = memw32(data);
XSRETURN(1);
void
_addfilebin(self, f)
SV * self
PerlIO * f
PREINIT:
SHA *state;
int n;
UCHR in[IO_BUFFER_SIZE];
PPCODE:
if (!f || (state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
while ((n = (int) PerlIO_read(f, in, sizeof(in))) > 0)
shawrite(in, (ULNG) n << 3, state);
XSRETURN(1);
void
_addfileuniv(self, f)
SV * self
PerlIO * f
PREINIT:
UCHR c;
int n;
int cr = 0;
UCHR *src, *dst;
UCHR in[IO_BUFFER_SIZE+1];
SHA *state;
PPCODE:
if (!f || (state = getSHA(aTHX_ self)) == NULL)
XSRETURN_UNDEF;
while ((n = (int) PerlIO_read(f, in+1, IO_BUFFER_SIZE)) > 0) {
for (dst = in, src = in + 1; n; n--) {
c = *src++;
if (!cr) {
if (c == '\015')
cr = 1;
else
*dst++ = c;
}
else {
if (c == '\015')
*dst++ = '\012';
else if (c == '\012') {
*dst++ = '\012';
cr = 0;
}
else {
*dst++ = '\012';
*dst++ = c;
cr = 0;
}
}
}
shawrite(in, (ULNG) (dst - in) << 3, state);
}
if (cr) {
in[0] = '\012';
shawrite(in, 1UL << 3, state);
}
XSRETURN(1);
