/*
Computes the array {C,lenB} of congruence classes $m \mod p$
for which we need to $\mu_i(m)$, in ascending order.
Returns the number of elements written into the array as
as lenC. Note that 1 <= lenC <= lenB.
*/
void _congruence_class(long *C, long *lenC, long ind,
const mon_t *B, long lenB,
long n, long d, long p)
{
long i, j, k, u, v;
*lenC = 0;
for (i = 0; i < lenB; i++)
for (j = 0; j < lenB; j++)
{
for (k = 0; k <= n; k++)
{
u = mon_get_exp(B[i], k);
v = mon_get_exp(B[j], k);
if ((p * (u + 1) - (v + 1)) % d != 0)
{
break;
}
}
if (k > n)
{
u = mon_get_exp(B[i], ind);
v = mon_get_exp(B[j], ind);
C[(*lenC)++] = ((p * (u + 1) - (v + 1)) / d) % p;
}
}
/* Remove duplicates */
_remove_duplicates(C, lenC);
_sort(C, *lenC);
}
static const char * _mount_options( unsigned long flags,string_t st )
{
if( flags & MS_NODEV ){
StringAppend( st,",nodev" ) ;
}
if( flags & MS_NOEXEC ){
StringAppend( st,",noexec" ) ;
}
if( flags & MS_NOSUID ){
StringAppend( st,",nosuid" ) ;
}
if( flags & MS_BIND ){
StringAppend( st,",bind" ) ;
}
if( flags & MS_MANDLOCK ){
StringAppend( st,",mandlock" ) ;
}
if( flags & MS_MOVE ){
StringAppend( st,",move" ) ;
}
if( flags & MS_NOATIME ){
StringAppend( st,",noatime" ) ;
}
if( flags & MS_NODIRATIME ){
StringAppend( st,",nodiratime" ) ;
}
if( flags & MS_RELATIME ){
StringAppend( st,",relatime" ) ;
}
if( flags & MS_REMOUNT ){
StringAppend( st,",remount" ) ;
}
if( flags & MS_SILENT ){
StringAppend( st,",silent" ) ;
}
if( flags & MS_STRICTATIME ){
StringAppend( st,",strictatime" ) ;
}
if( flags & MS_SYNCHRONOUS ){
StringAppend( st,",synchronous" ) ;
}
return _remove_duplicates( st ) ;
}
static string_t set_mount_options( m_struct * mst )
{
/*
* zuluCryptGetMountOptionsFromFstab() is defined in parse_fstab.c
*/
string_t opt = zuluCryptGetMountOptionsFromFstab( mst->device,MOUNTOPTIONS,mst->uid ) ;
int fsFamily = fs_family( mst->fs ) ;
const char * f[] = { "nouser","users","user","defaults","noauto","auto","nodev","dev",
"noexec","exec","nosuid","suid","bind","mandlock","move","noatime","nodiratime","remount","silent",
"synchronous",NULL } ;
const char ** z = f ;
const char * e ;
if( opt == StringVoid ){
opt = String( "" ) ;
StringAppend( opt,mst->fs_flags ) ;
}else{
if( StringContains( opt,"ro" ) ){
mst->m_flags |= MS_RDONLY ;
}
StringMultipleAppend( opt,",",mst->fs_flags,END ) ;
}
_get_file_system_options_from_config_file( mst->device,opt ) ;
if( fsFamily == 1 ){
if( !StringContains( opt,"dmask=" ) ){
StringAppend( opt,",dmask=0000" ) ;
}
if( !StringContains( opt,"umask=" ) ){
StringAppend( opt,",umask=0000" ) ;
}
if( !StringContains( opt,"uid=" ) ){
StringAppend( opt,",uid=" ) ;
StringAppendInt( opt,mst->uid ) ;
}
if( !StringContains( opt,"gid=" ) ){
StringAppend( opt,",gid=" ) ;
StringAppendInt( opt,mst->uid ) ;
}
if( !StringContains( opt,"fmask=" ) ){
StringAppend( opt,",fmask=0111" ) ;
}
if( StringsAreEqual( mst->fs,"vfat" ) ){
if( !StringContains( opt,"flush" ) ){
StringAppend( opt,",flush" ) ;
}
if( !StringContains( opt,"shortname=" ) ){
StringAppend( opt,",shortname=mixed" ) ;
}
}
}else if( fsFamily == 2 ){
if( !StringContains( opt,"uid=" ) ){
StringAppend( opt,",uid=" ) ;
StringAppendInt( opt,mst->uid ) ;
}
if( !StringContains( opt,"gid=" ) ){
StringAppend( opt,",gid=" ) ;
StringAppendInt( opt,mst->uid ) ;
}
}else if( fsFamily == 3 ){
mst->m_flags |= MS_RDONLY ;
}else{
/*
* ext file systems and raiserfs among others go here
* we dont set any options for them.
*/
;
}
/*
* remove mount options to leave only file system options
*/
while( 1 ){
e = *z ;
z++ ;
if( e == NULL ){
break ;
}else{
StringRemoveString( opt,e ) ;
}
}
/*
* remove below two now because we are going to add them below,reason for removing them
* and readding them is because we want to make sure they are at the beginning of the string
*/
StringRemoveString( opt,"ro" ) ;
StringRemoveString( opt,"rw" ) ;
if( mst->m_flags & MS_RDONLY ){
StringPrepend( opt,"ro," ) ;
}else{
StringPrepend( opt,"rw," ) ;
}
mst->opts = _remove_duplicates( opt ) ;
return opt;
}
void precompute_muex(fmpz **mu, long M,
const long **C, const long *lenC,
const fmpz *a, long n, long p, long N)
{
const long ve = (p == 2) ? M / 4 + 1 : M / (p * (p - 1)) + 1;
fmpz_t P, pNe, pe;
fmpz_t apow, f, g, h;
fmpz *nu;
long *v;
long i, j;
fmpz_init_set_ui(P, p);
fmpz_init(pNe);
fmpz_init(pe);
fmpz_pow_ui(pNe, P, N + ve);
fmpz_pow_ui(pe, P, ve);
fmpz_init(apow);
fmpz_init(f);
fmpz_init(g);
fmpz_init(h);
/* Precompute $(l!)^{-1}$ */
nu = _fmpz_vec_init(M + 1);
v = malloc((M + 1) * sizeof(long));
{
long *D, lenD = 0, k = 0;
for (i = 0; i <= n; i++)
lenD += lenC[i];
D = malloc(lenD * sizeof(long));
for (i = 0; i <= n; i++)
for (j = 0; j < lenC[i]; j++)
D[k++] = C[i][j];
_remove_duplicates(D, &lenD);
_sort(D, lenD);
precompute_nu(nu, v, M, D, lenD, p, N + ve);
free(D);
}
for (i = 0; i <= n; i++)
{
long m = -1, quo, idx, w;
fmpz *z;
/* Set apow = a[i]^{-(p-1)} mod p^N */
fmpz_invmod(apow, a + i, pNe);
fmpz_powm_ui(apow, apow, p - 1, pNe);
/*
Run over all relevant m in [0, M].
Note that lenC[i] > 0 for all i.
*/
for (quo = 0; m <= M; quo++)
{
for (idx = 0; idx < lenC[i]; idx++)
{
m = quo * p + C[i][idx];
if (m > M)
break;
/*
Note that $\mu_m$ is equal to
$\sum_{k=0}^{\floor{m/p}} p^{\floor{m/p}-k}\nu_{m-pk}\nu_k$
where $\nu_i$ denotes the number with unit part nu[i]
and valuation v[i].
*/
w = (p == 2) ? (3 * m) / 4 - (m == 3 || m == 7) : m / p;
z = mu[i] + lenC[i] * quo + idx;
fmpz_zero(z);
fmpz_one(h);
for (j = 0; j <= m / p; j++)
{
fmpz_pow_ui(f, P, ve + w - j + v[m - p*j] + v[j]);
fmpz_mul(g, nu + (m - p*j), nu + j);
fmpz_mul(f, f, g);
fmpz_mul(f, f, h);
fmpz_add(z, z, f);
fmpz_mod(z, z, pNe);
/* Set h = a[i]^{- (j+1)(p-1)} mod p^{N+e} */
fmpz_mul(h, h, apow);
fmpz_mod(h, h, pNe);
}
fmpz_divexact(z, z, pe);
}
}
}
fmpz_clear(P);
fmpz_clear(pNe);
fmpz_clear(pe);
fmpz_clear(apow);
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(h);
_fmpz_vec_clear(nu, M + 1);
free(v);
}
