File Coverage

BsDiPa.xs

Criterion	Covered	Total	%
statement	150	166	90.3
branch	81	108	75.0
condition			n/a
subroutine			n/a
pod			n/a
total	231	274	84.3

/*@ BsDiPa.xs: perl XS interface of/to S-bsdipa.
 *@
 *@ Remarks:
 *@ - code requires ISO STD C99 (for now).
 *
 * Copyright (c) 2024 - 2026 Steffen Nurpmeso .
 * SPDX-License-Identifier: ISC
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/* assert()ions (otherwise uncomment OPTIMIZE in Makefile.PL) */
/*#define DEBUGGING*/
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include

#define s_BSDIPA_IO_READ
#define s_BSDIPA_IO_WRITE
/**/
#if s__BSDIPA_BZ2
# undef s_BSDIPA_IO
# define s_BSDIPA_IO s_BSDIPA_IO_BZ2
# include "c-lib/s-bsdipa-io.h"
#endif
/**/
#undef s_BSDIPA_IO
#define s_BSDIPA_IO s_BSDIPA_IO_RAW
#include "c-lib/s-bsdipa-io.h"
/**/
#if s__BSDIPA_XZ
# undef s_BSDIPA_IO
# define s_BSDIPA_IO s_BSDIPA_IO_XZ
# include "c-lib/s-bsdipa-io.h"
#endif
/**/
#undef s_BSDIPA_IO
#define s_BSDIPA_IO s_BSDIPA_IO_ZLIB
#include "c-lib/s-bsdipa-io.h"
/**/
#if s__BSDIPA_ZSTD
# undef s_BSDIPA_IO
# define s_BSDIPA_IO s_BSDIPA_IO_ZSTD
# include "c-lib/s-bsdipa-io.h"
#endif

#include
#include

#define a_LEVEL_SET(LS,LV) LS = (LV < 0 ? 0 : LV > 9 ? 9 : LV)

union a_io_cookie{
	void *ioc_vp;
	struct s_bsdipa_io_cookie *ioc_iocp;
#if s__BSDIPA_XZ
	struct s_bsdipa_io_cookie_xz *ioc_iocJp;
#endif
#if s__BSDIPA_ZSTD
	struct s_bsdipa_io_cookie_zstd *ioc_iocZp;
#endif
};

static IV a_try_oneshot = -1;
static IV a_level = 0;
static IV const a_have_bz2 = s__BSDIPA_BZ2;
static IV const a_have_xz = s__BSDIPA_XZ;
static IV const a_have_zstd = s__BSDIPA_ZSTD;

static void *a_alloc(size_t size);
static void a_free(void *vp);

static SV *a_core_diff(int what, SV *before_sv, SV *after_sv, SV *patch_sv, SV *magic_window, SV *is_equal_data,
		SV *io_cookie);
static enum s_bsdipa_state a_core_diff__write(void *user_cookie, uint8_t const *dat, s_bsdipa_off_t len,
		s_bsdipa_off_t is_last);
#ifdef s_BSDIPA_TEXT
/* Must be proof against "algorithmic complexity attacks" by default! */
static uint32_t a_core_diff__hash(void *user_cookie, uint8_t const *dat, size_t len);
#endif

static SV *a_core_patch(int what, SV *after_sv, SV *patch_sv, SV *before_sv, SV *max_allowed_restored_len,
		SV *io_cookie);

static void *
a_alloc(size_t size){
	char *vp;

	Newx(vp, size, char);

	return vp;
}

static void
a_free(void *vp){
	Safefree(vp);
}

static SV *
a_core_diff(int what, SV *before_sv, SV *after_sv, SV *patch_sv, SV *magic_window, SV *is_equal_data, SV *io_cookie){
	struct s_bsdipa_io_cookie ioc, *iocp;
	struct s_bsdipa_diff_ctx d;
	SV *pref, *iseq;
	enum s_bsdipa_state s;

	s = s_BSDIPA_INVAL;

	pref = NULL;
	if(/*!SvOK(patch_sv) ||*/ !SvROK(patch_sv))
		goto jleave;
	pref = SvRV(patch_sv);

	if(/*!SvOK(before_sv) ||*/ !SvPOK(before_sv))
		goto jleave;

	if(/*!SvOK(after_sv) ||*/ !SvPOK(after_sv))
		goto jleave;

	d.dc_mem.mc_alloc = &a_alloc;
	d.dc_mem.mc_free = &a_free;
	d.dc_before_len = SvCUR(before_sv);
	d.dc_before_dat = SvPVbyte_nolen(before_sv);
	d.dc_after_len = SvCUR(after_sv);
	d.dc_after_dat = SvPVbyte_nolen(after_sv);
	d.dc_magic_window = 0;
#ifdef s_BSDIPA_TEXT
	d.dc_text_mode = 0;
#endif

	if(magic_window == NULL || !SvOK(magic_window)){
	}else if(!SvIOK(magic_window))
		goto jleave;
	else{
		IV i;

		i = SvIV(magic_window);
		if(i > 4096) /* <> docu! */
			goto jleave;
		if(i >= 0)
			d.dc_magic_window = (int32_t)i;
#ifdef s_BSDIPA_TEXT
		else{
			d.dc_text_mode = 1;
			d.dc_hash = &a_core_diff__hash;
			/*d.dc_hash_cookie =*/
		}
#endif
	}

	if(is_equal_data == NULL || !SvOK(is_equal_data))
		iseq = NULL;
	else if(!SvROK(is_equal_data))
		goto jleave;
	else
		iseq = SvRV(is_equal_data);

	if(io_cookie == NULL || !SvIOK(io_cookie)){
		if(a_level == 0)
			iocp = NULL;
		else{
			memset(iocp = &ioc, 0, sizeof(ioc));
			iocp->ioc_level = a_level;
		}
	}else
		iocp = INT2PTR(struct s_bsdipa_io_cookie*,SvIV(io_cookie));

	s = s_bsdipa_diff(&d);
	if(s != s_BSDIPA_OK)
		goto jdone;

	if(iseq != NULL)
		SvIV_set(iseq, d.dc_is_equal_data);

	/* _RAW is very "unlikely" */
	SvPVCLEAR(pref);
	if(what == s_BSDIPA_IO_ZLIB)
		s = s_bsdipa_io_write_zlib(&d, &a_core_diff__write, pref, a_try_oneshot, iocp);
#if s__BSDIPA_BZ2
	else if(what == s_BSDIPA_IO_BZ2)
		s = s_bsdipa_io_write_bz2(&d, &a_core_diff__write, pref, a_try_oneshot, iocp);
#endif
#if s__BSDIPA_XZ
	else if(what == s_BSDIPA_IO_XZ)
		s = s_bsdipa_io_write_xz(&d, &a_core_diff__write, pref, a_try_oneshot, iocp);
#endif
#if s__BSDIPA_ZSTD
	else if(what == s_BSDIPA_IO_ZSTD)
		s = s_bsdipa_io_write_zstd(&d, &a_core_diff__write, pref, a_try_oneshot, iocp);
#endif
	else /*if(what == s_BSDIPA_IO_RAW)*/{
		s_bsdipa_off_t x;

		x = sizeof(d.dc_header) + d.dc_ctrl_len + d.dc_diff_len + d.dc_extra_len +1;
		SvGROW(pref, x);
		SvCUR_set(pref, 0);
		s = s_bsdipa_io_write_raw(&d, &a_core_diff__write, pref, a_try_oneshot, iocp);
	}

jdone:
	s_bsdipa_diff_free(&d);

jleave:
	if(s != s_BSDIPA_OK && pref != NULL)
		sv_setsv(pref, &PL_sv_undef);

	return newSViv(s);
}

static enum s_bsdipa_state
a_core_diff__write(void *user_cookie, uint8_t const *dat, s_bsdipa_off_t len, s_bsdipa_off_t is_last){
	SV *p;
	enum s_bsdipa_state rv;

	if(is_last >= 0 && len <= 0)
		goto jok;

	p = (SV*)user_cookie;

	/* Buffer takeover?  Even though likely short living, minimize wastage to XXX something reasonable */
	if(is_last < 0 && (is_last > -65535 || is_last / 10 > -len)){
		/* In this case the additional byte is guaranteed! */
		((uint8_t*)dat)[(unsigned long)len] = '\0';
		sv_usepvn_flags(p, (char*)dat, len, SV_SMAGIC | SV_HAS_TRAILING_NUL);
		assert(SvPVbyte_nolen(p)[SvCUR(p)] == '\0');
		/*xxx instead sv_setpvn(p, dat, len);*/
	}else{
		char *cp;
		s_bsdipa_off_t l;

		l = (s_bsdipa_off_t)SvCUR(p);

		cp = SvGROW(p, l + len +1);
		if(cp == NULL){
			rv = s_BSDIPA_NOMEM;
			goto jleave;
		}

		memcpy(&cp[(unsigned long)l], dat, len);
		l += len;
		cp[(unsigned long)l] = '\0'; /* mumble */
		SvCUR_set(p, l);
		SvPOK_only(p);
		SvSETMAGIC(p);
		assert(SvPVbyte_nolen(p)[SvCUR(p)] == '\0');

		if(is_last < 0)
			a_free((void*)dat);
	}

jok:
	rv = s_BSDIPA_OK;
jleave:
	return rv;
}

#ifdef s_BSDIPA_TEXT
static uint32_t
a_core_diff__hash(void *user_cookie, uint8_t const *dat, size_t len){
	U32 h;
	STRLEN l;
	U8 const *p;
	(void)user_cookie;

	p = (U8 const*)dat;
	l = (STRLEN)len;
	h = 0;
	PERL_HASH(h, p, l);

	return h;
}
#endif

static SV *
a_core_patch(int what, SV *after_sv, SV *patch_sv, SV *before_sv, SV *max_allowed_restored_len, SV *io_cookie){
	struct s_bsdipa_patch_ctx p;
	struct s_bsdipa_io_cookie *iocp;
	SV *bref;
	enum s_bsdipa_state s;

	s = s_BSDIPA_INVAL;

	bref = NULL;
	if(/*!SvOK(before_sv) ||*/ !SvROK(before_sv))
		goto jleave;
	bref = SvRV(before_sv);

	if(/*!SvOK(after_sv) ||*/ !SvPOK(after_sv))
		goto jleave;

	if(/*!SvOK(patch_sv) ||*/ !SvPOK(patch_sv))
		goto jleave;

	p.pc_max_allowed_restored_len = 0;
	if(max_allowed_restored_len != NULL && SvOK(max_allowed_restored_len)){
		if(!SvIOK(max_allowed_restored_len))
			goto jleave;
		else{
			IV i;

			i = SvIV(max_allowed_restored_len);
			if(i < 0 || (uint64_t)i != (s_bsdipa_off_t)i ||
					(s_bsdipa_off_t)i >= s_BSDIPA_OFF_MAX)
				goto jleave;
			p.pc_max_allowed_restored_len = (uint64_t)i;
		}
	}

	if(io_cookie == NULL || !SvIOK(io_cookie))
		iocp = NULL;
	else
		iocp = INT2PTR(struct s_bsdipa_io_cookie*,SvIV(io_cookie));

	p.pc_mem.mc_alloc = &a_alloc;
	p.pc_mem.mc_free = &a_free;
	p.pc_after_len = SvCUR(after_sv);
	p.pc_after_dat = SvPVbyte_nolen(after_sv);

	p.pc_patch_len = SvCUR(patch_sv);
	p.pc_patch_dat = SvPVbyte_nolen(patch_sv);

	/* _RAW is very "unlikely" */
	if(what == s_BSDIPA_IO_ZLIB)
		s = s_bsdipa_io_read_zlib(&p, iocp);
#if s__BSDIPA_BZ2
	else if(what == s_BSDIPA_IO_BZ2)
		s = s_bsdipa_io_read_bz2(&p, iocp);
#endif
#if s__BSDIPA_XZ
	else if(what == s_BSDIPA_IO_XZ)
		s = s_bsdipa_io_read_xz(&p, iocp);
#endif
#if s__BSDIPA_ZSTD
	else if(what == s_BSDIPA_IO_ZSTD)
		s = s_bsdipa_io_read_zstd(&p, iocp);
#endif
	else /*if(what == s_BSDIPA_IO_RAW)*/
		s = s_bsdipa_io_read_raw(&p, iocp);
	if(s != s_BSDIPA_OK)
		goto jleave;

	p.pc_patch_dat = p.pc_restored_dat;
	p.pc_patch_len = p.pc_restored_len;

	s = s_bsdipa_patch(&p);

	a_free((void*)p.pc_patch_dat);

	if(s != s_BSDIPA_OK)
		goto jdone;

	/* Hand buffer over to perl */
	p.pc_restored_dat[(size_t)p.pc_restored_len] = '\0';
	SvPVCLEAR(bref); /* xxx needless? */
	sv_usepvn_flags(bref, (char*)p.pc_restored_dat, p.pc_restored_len, SV_SMAGIC | SV_HAS_TRAILING_NUL);
	assert(SvPVbyte_nolen(bref)[SvCUR(bref)] == '\0');
	p.pc_restored_dat = NULL;

jdone:
	s_bsdipa_patch_free(&p);

jleave:
	if(s != s_BSDIPA_OK && bref != NULL)
		sv_setsv(bref, &PL_sv_undef);

	return newSViv(s);
}

MODULE = BsDiPa PACKAGE = BsDiPa
VERSIONCHECK: DISABLE
PROTOTYPES: ENABLE

SV *
VERSION()
CODE:
	RETVAL = newSVpv(s_BSDIPA_VERSION, sizeof(s_BSDIPA_VERSION) -1);
OUTPUT:
	RETVAL

SV *
CONTACT()
CODE:
	RETVAL = newSVpv(s_BSDIPA_CONTACT, sizeof(s_BSDIPA_CONTACT) -1);
OUTPUT:
	RETVAL

SV *
COPYRIGHT()
CODE:
	RETVAL = newSVpv(s_BSDIPA_COPYRIGHT, sizeof(s_BSDIPA_COPYRIGHT) -1);
OUTPUT:
	RETVAL

SV *
HAVE_BZ2()
CODE:
	RETVAL = newSViv(a_have_bz2);
OUTPUT:
	RETVAL

SV *
HAVE_XZ()
CODE:
	RETVAL = newSViv(a_have_xz);
OUTPUT:
	RETVAL

SV *
HAVE_ZSTD()
CODE:
	RETVAL = newSViv(a_have_zstd);
OUTPUT:
	RETVAL

SV *
OK()
CODE:
	RETVAL = newSViv(s_BSDIPA_OK);
OUTPUT:
	RETVAL

SV *
FBIG()
CODE:
	RETVAL = newSViv(s_BSDIPA_FBIG);
OUTPUT:
	RETVAL

SV *
NOMEM()
CODE:
	RETVAL = newSViv(s_BSDIPA_NOMEM);
OUTPUT:
	RETVAL

SV *
INVAL()
CODE:
	RETVAL = newSViv(s_BSDIPA_INVAL);
OUTPUT:
	RETVAL

void
core_try_oneshot_set(nval)
	SV *nval
CODE:
	if(SvIOK(nval))
		a_try_oneshot = SvIV(nval);

void
core_diff_level_set(nval)
	SV *nval
CODE:
	if(SvIOK(nval)){
		a_level = SvIV(nval);
		a_LEVEL_SET(a_level, a_level);
	}

SV *
core_diff_raw(before_sv, after_sv, patch_sv, magic_window=NULL, is_equal_data=NULL, io_cookie=NULL)
	SV *before_sv
	SV *after_sv
	SV *patch_sv
	SV *magic_window
	SV *is_equal_data
	SV *io_cookie
CODE:
	RETVAL = a_core_diff(s_BSDIPA_IO_RAW, before_sv, after_sv, patch_sv, magic_window, is_equal_data, io_cookie);
OUTPUT:
	RETVAL

SV *
core_diff_zlib(before_sv, after_sv, patch_sv, magic_window=NULL, is_equal_data=NULL, io_cookie=NULL)
	SV *before_sv
	SV *after_sv
	SV *patch_sv
	SV *magic_window
	SV *is_equal_data
	SV *io_cookie
CODE:
	RETVAL = a_core_diff(s_BSDIPA_IO_ZLIB, before_sv, after_sv, patch_sv, magic_window, is_equal_data, io_cookie);
OUTPUT:
	RETVAL

#if s__BSDIPA_BZ2
SV *
core_diff_bz2(before_sv, after_sv, patch_sv, magic_window=NULL, is_equal_data=NULL, io_cookie=NULL)
	SV *before_sv
	SV *after_sv
	SV *patch_sv
	SV *magic_window
	SV *is_equal_data
	SV *io_cookie
CODE:
	RETVAL = a_core_diff(s_BSDIPA_IO_BZ2, before_sv, after_sv, patch_sv, magic_window, is_equal_data, io_cookie);
OUTPUT:
	RETVAL
#endif

#if s__BSDIPA_XZ
SV *
core_diff_xz(before_sv, after_sv, patch_sv, magic_window=NULL, is_equal_data=NULL, io_cookie=NULL)
	SV *before_sv
	SV *after_sv
	SV *patch_sv
	SV *magic_window
	SV *is_equal_data
	SV *io_cookie
CODE:
	RETVAL = a_core_diff(s_BSDIPA_IO_XZ, before_sv, after_sv, patch_sv, magic_window, is_equal_data, io_cookie);
OUTPUT:
	RETVAL
#endif

#if s__BSDIPA_ZSTD
SV *
core_diff_zstd(before_sv, after_sv, patch_sv, magic_window=NULL, is_equal_data=NULL, io_cookie=NULL)
	SV *before_sv
	SV *after_sv
	SV *patch_sv
	SV *magic_window
	SV *is_equal_data
	SV *io_cookie
CODE:
	RETVAL = a_core_diff(s_BSDIPA_IO_ZSTD, before_sv, after_sv, patch_sv, magic_window, is_equal_data, io_cookie);
OUTPUT:
	RETVAL
#endif

SV *
core_patch_raw(after_sv, patch_sv, before_sv, max_allowed_restored_len=NULL, io_cookie=NULL)
	SV *after_sv
	SV *patch_sv
	SV *before_sv
	SV *max_allowed_restored_len
	SV *io_cookie
CODE:
	RETVAL = a_core_patch(s_BSDIPA_IO_RAW, after_sv, patch_sv, before_sv, max_allowed_restored_len, io_cookie);
OUTPUT:
	RETVAL

SV *
core_patch_zlib(after_sv, patch_sv, before_sv, max_allowed_restored_len=NULL, io_cookie=NULL)
	SV *after_sv
	SV *patch_sv
	SV *before_sv
	SV *max_allowed_restored_len
	SV *io_cookie
CODE:
	RETVAL = a_core_patch(s_BSDIPA_IO_ZLIB, after_sv, patch_sv, before_sv, max_allowed_restored_len, io_cookie);
OUTPUT:
	RETVAL

#if s__BSDIPA_BZ2
SV *
core_patch_bz2(after_sv, patch_sv, before_sv, max_allowed_restored_len=NULL, io_cookie=NULL)
	SV *after_sv
	SV *patch_sv
	SV *before_sv
	SV *max_allowed_restored_len
	SV *io_cookie
CODE:
	RETVAL = a_core_patch(s_BSDIPA_IO_BZ2, after_sv, patch_sv, before_sv, max_allowed_restored_len, io_cookie);
OUTPUT:
	RETVAL
#endif

#if s__BSDIPA_XZ
SV *
core_patch_xz(after_sv, patch_sv, before_sv, max_allowed_restored_len=NULL, io_cookie=NULL)
	SV *after_sv
	SV *patch_sv
	SV *before_sv
	SV *max_allowed_restored_len
	SV *io_cookie
CODE:
	RETVAL = a_core_patch(s_BSDIPA_IO_XZ, after_sv, patch_sv, before_sv, max_allowed_restored_len, io_cookie);
OUTPUT:
	RETVAL
#endif

#if s__BSDIPA_ZSTD
SV *
core_patch_zstd(after_sv, patch_sv, before_sv, max_allowed_restored_len=NULL, io_cookie=NULL)
	SV *after_sv
	SV *patch_sv
	SV *before_sv
	SV *max_allowed_restored_len
	SV *io_cookie
CODE:
	RETVAL = a_core_patch(s_BSDIPA_IO_ZSTD, after_sv, patch_sv, before_sv, max_allowed_restored_len, io_cookie);
OUTPUT:
	RETVAL
#endif

#if s__BSDIPA_XZ
SV *
core_io_cookie_new_xz(level=NULL)
	SV *level
CODE:
	struct s_bsdipa_io_cookie_xz *iocJp;
	IV lvl;

	lvl = (level != NULL && SvIOK(level)) ? SvIV(level) : 0;

	iocJp = (struct s_bsdipa_io_cookie_xz*)a_alloc(sizeof(*iocJp));
	memset(iocJp, 0, sizeof(*iocJp));
	iocJp->iocx_super.ioc_type = s_BSDIPA_IO_XZ;
	a_LEVEL_SET(iocJp->iocx_super.ioc_level, lvl);
	RETVAL = newSViv(PTR2IV(iocJp));
OUTPUT:
	RETVAL
#endif

#if s__BSDIPA_ZSTD
SV *
core_io_cookie_new_zstd(level=NULL)
	SV *level
CODE:
	struct s_bsdipa_io_cookie_zstd *iocZp;
	IV lvl;

	lvl = (level != NULL && SvIOK(level)) ? SvIV(level) : 0;

	iocZp = (struct s_bsdipa_io_cookie_zstd*)a_alloc(sizeof(*iocZp));
	memset(iocZp, 0, sizeof(*iocZp));
	iocZp->iocZ_super.ioc_type = s_BSDIPA_IO_ZSTD;
	a_LEVEL_SET(iocZp->iocZ_super.ioc_level, lvl);
	RETVAL = newSViv(PTR2IV(iocZp));
OUTPUT:
	RETVAL
#endif

void
core_io_cookie_gut(io_cookie)
	SV *io_cookie
CODE:
	if(io_cookie != NULL && SvIOK(io_cookie)){
		union a_io_cookie ioc;

		ioc.ioc_vp = INT2PTR(void*,SvIV(io_cookie));

		if(ioc.ioc_vp != NULL){
#if s__BSDIPA_XZ
			if(ioc.ioc_iocp->ioc_type == s_BSDIPA_IO_XZ)
				s_bsdipa_io_cookie_gut_xz(ioc.ioc_iocp);
#endif
#if s__BSDIPA_ZSTD
			if(ioc.ioc_iocp->ioc_type == s_BSDIPA_IO_ZSTD)
				s_bsdipa_io_cookie_gut_zstd(ioc.ioc_iocp);
#endif
			a_free(ioc.ioc_vp);
		}
	}