matrix* Schur_char(entry* lambda, lie_Index l)
{ lie_Index i,n=check_part(lambda,l); entry np=n_parts(n);
matrix* result=mkmatrix(np,n+1); entry** res=result->elm;
res[0][0]=n; for (i=1; i<n; ++i) res[0][i]=0; i=0;
while (res[i][n]=Schur_char_val(lambda,res[i],l,n),++i<np)
{ copyrow(res[i-1],res[i],n); Nextpart(res[i],n); }
return result;
}
static void
post_UR(CHKARGS)
{
if (n->type == ROFFT_HEAD && n->child == NULL)
mandoc_msg(MANDOCERR_UR_NOHEAD, n->line, n->pos,
"%s", roff_name[n->tok]);
check_part(man, n);
}
static void
post_UR(CHKARGS)
{
if (n->type == MAN_HEAD && n->child == NULL)
mandoc_vmsg(MANDOCERR_UR_NOHEAD, man->parse,
n->line, n->pos, "UR");
check_part(man, n);
}
bigint* MN_char_val(entry* lambda, entry* mu, lie_Index l, lie_Index m)
{ bigint* value=null; lie_Index n=check_part(lambda,l),m2;
if (n==0) return one;
while (lambda[l-1]==0) --l; while (mu[m-1]==0) --m;
for (m2=m; m2>0 && mu[m2-1]==1; --m2) {} /* number of parts $\mu_i\geq2$ */
{ entry* save=mkintarray(2*n),* lambda_prime=save+n;
int i, j, d=lambda[0]+l, k=0; /* sum of leg lengths */
boolean* edge=alloc_array(boolean,2*d);
enum {hor, vert};
{ int r=l-1,c=0; /* current column number */
for (j=0; r>=0; --r)
{ while (c<lambda[r]) { edge[j++]=hor; ++c; } /* columns of length |r| */
edge[j++]=vert; /* row |r|, of length |c==lambda[r]| */
}
}
for (i=0; i<m2; ++i)
{ for (j=0; j+mu[i]<d; ++j)
if (edge[j]==hor && edge[j+mu[i]]==vert) break;
if (j+mu[i]==d) return null; /* no hook of size |mu[i]| was found */
}
{ i=0; /* index into |mu| */
recurse:
if (i<m2)
{ int r=mu[i];
for (j=1; j<r; ++j) k+=edge[j]; /* leg length of hook first tried */
for (j=0; j+r<d; ++j)
{ if (edge[j]==hor && edge[j+r]==vert)
{ edge[j]=vert; edge[j+r]=hor; save[i++]=j; goto recurse;
resume: j=save[--i]; r=mu[i]; edge[j]=hor; edge[j+r]=vert;
}
k+= edge[j+r]-edge[j+1]; /* adjust |k| for hook tried next */
}
while (++j<d) k-= edge[j]; /* restore |k| */
}
else
{ int r=l,c=0,s=0; /* size of |lambda_prime| */
for (j=0; r>0; )
if (edge[j++]==vert) s+=lambda_prime[--r]=c; else ++c;
/* build |lambda_prime| from edges */
value= k%2==0 ? add(value,n_tableaux(lambda_prime,l))
: sub(value,n_tableaux(lambda_prime,l)) ;
}
if (i>0) goto resume;
}
freearr(edge); freearr(save);
}
return value;
}
matrix* Tableaux(entry* lambda, lie_Index l)
{ bigint* nt=n_tableaux(lambda,l); lie_Index n=check_part(lambda,l);
matrix* result=mkmatrix(bigint2entry(nt),n);
entry** res=result->elm,* t=mkintarray(n);
freemem(nt);
{ lie_Index i=0,j,k;
for (j=1; j<=l; ++j) for (k=lambda[j-1]; k>0; --k) t[i++]=j;
}
{ lie_Index i=0; do copyrow(t,res[i++],n); while(Nexttableau(t,n)); }
freearr(t); return result;
}
static void
chartable_symbol_callback (struct rspamd_task *task, void *unused)
{
guint i;
struct mime_text_part *part;
for (i = 0; i < task->text_parts->len; i ++) {
part = g_ptr_array_index (task->text_parts, i);
if (!IS_PART_EMPTY (part) && check_part (part, task->cfg->raw_mode)) {
rspamd_task_insert_result (task, chartable_module_ctx->symbol, 1, NULL);
}
}
}
ldc_diag_t * diag(int log, ldc_info_t * info) {
ldc_info_t * current_info;
ldc_diag_t * head = NULL;
ldc_diag_t * tail = NULL;
for (current_info = info; current_info != NULL; current_info = current_info->next) {
tail = new_ldc_diag_t("usbstorage");
head = enqueue_ldc_diag_t(head, tail);
// find the logical_name in info
tuple_t * current_tuple;
for (current_tuple = current_info->info; current_tuple != NULL && strcmp(current_tuple->name, "device_file") != 0; current_tuple = current_tuple->next);
if (current_tuple) {
char name[100];
char value[1000];
int id;
char description[100];
int* part_list = get_part_list(current_info);
int part_result = check_part(part_list);
SETUP_TUPLE("partition_check", "NULL", part_result, "Partition Check");
tail->info = enqueue_new_tuple_t(tail->info, name, value, id, description);
int mount_result = mount_test(current_tuple->value, part_list);
SETUP_TUPLE("mount_test", "NULL", mount_result, "Mount Test");
tail->info = enqueue_new_tuple_t(tail->info, name, value, id, description);
int fsck_result = fsck_test(current_tuple->value, part_list);
SETUP_TUPLE("fsck_test", "NULL", fsck_result, "Fsck Test");
tail->info = enqueue_new_tuple_t(tail->info, name, value, id, description);
}
}
if (log){
insert_diag_log(head);
}
return head;
}
poly* MN_char(entry* lambda, lie_Index l)
{ lie_Index n=check_part(lambda,l);
if (n==0) return poly_one(0); /* the character of $\Sym0$ */
while (lambda[l-1]==0) --l; /* minimise |l| */
wt_init(n); /* get ready for accumulating contributions to the character */
{
entry* mu=mkintarray(3*n),* save=mu+n,* lambda_prime=save+n;
int i, j, r, d=lambda[0]+l, k=0; /* sum of leg lengths */
boolean* edge=alloc_array(boolean,2*d-2),* candidate=edge+d-2;
/* lie_Index |2<=r<d| */
enum {hor, vert}; /* values used for |edge| */
for (i=0; i<n; ++i) mu[i]=0;
{ int r=l-1,c=0; /* current column number */
for (j=0; r>=0; --r)
{ while (c<lambda[r]) { edge[j++]=hor; ++c; } /* columns of length |r| */
edge[j++]=vert; /* row |r|, of length |c==lambda[r]| */
}
}
for (r=2; r<d; ++r)
{ for (j=0; j+r<d; ++j)
if (edge[j]==hor && edge[j+r]==vert) break;
candidate[r]= j+r<d;
}
{ i=0; /* index of last entry that was set in~|mu| */
for (r=d-1; r>1; --r) /* try hooks of size |r| */
if (candidate[r])
{ recurse: /* recursive starting point */
{ for (j=1; j<r; ++j) k+=edge[j]; /* leg length of hook first tried */
for (j=0; j<d-r; ++j)
{ if (edge[j]==hor && edge[j+r]==vert)
{ edge[j]=vert; edge[j+r]=hor; mu[i]=r; save[i++]=j; goto recurse;
resume: j=save[--i]; r=mu[i]; mu[i]=0; edge[j]=hor; edge[j+r]=vert;
}
k+= edge[j+r]-edge[j+1]; /* adjust |k| for hook tried next */
}
while (++j<d) k-= edge[j]; /* restore |k| */
}
}
}
{ int r=l,c=0,s=0; /* size of |lambda_prime| */
for (j=0; r>0; )
if (edge[j++]==vert) s+=lambda_prime[--r]=c; else ++c;
/* build |lambda_prime| from edges */
for (j=0; j<s; ++j) mu[i++]=1; /* extend |mu| with |s| ones */
wt_ins(mu,n_tableaux(lambda_prime,l),k%2);
for (j=0; j<s; ++j) mu[--i]=0; /* remove the ones again */
}
if (i>0) goto resume;
{ freearr(edge); freearr(mu); }
}
return wt_collect();
}
int
mbrinit(cdev_t dev, struct disk_info *info, struct diskslices **sspp)
{
struct buf *bp;
u_char *cp;
int dospart;
struct dos_partition *dp;
struct dos_partition *dp0;
struct dos_partition dpcopy[NDOSPART];
int error;
int max_ncyls;
int max_nsectors;
int max_ntracks;
u_int64_t mbr_offset;
char partname[2];
u_long secpercyl;
char *sname = "tempname";
struct diskslice *sp;
struct diskslices *ssp;
cdev_t wdev;
mbr_offset = DOSBBSECTOR;
reread_mbr:
/*
* Don't bother if the block size is weird or the
* media size is 0 (probably means no media present).
*/
if (info->d_media_blksize & DEV_BMASK)
return (EIO);
if (info->d_media_size == 0)
return (EIO);
/*
* Read master boot record.
*/
wdev = dev;
bp = geteblk((int)info->d_media_blksize);
bp->b_bio1.bio_offset = (off_t)mbr_offset * info->d_media_blksize;
bp->b_bio1.bio_done = biodone_sync;
bp->b_bio1.bio_flags |= BIO_SYNC;
bp->b_bcount = info->d_media_blksize;
bp->b_cmd = BUF_CMD_READ;
bp->b_flags |= B_FAILONDIS;
dev_dstrategy(wdev, &bp->b_bio1);
if (biowait(&bp->b_bio1, "mbrrd") != 0) {
if ((info->d_dsflags & DSO_MBRQUIET) == 0) {
diskerr(&bp->b_bio1, wdev,
"reading primary partition table: error",
LOG_PRINTF, 0);
kprintf("\n");
}
error = EIO;
goto done;
}
/* Weakly verify it. */
cp = bp->b_data;
sname = dsname(dev, 0, 0, 0, NULL);
if (cp[0x1FE] != 0x55 || cp[0x1FF] != 0xAA) {
if (bootverbose)
kprintf("%s: invalid primary partition table: no magic\n",
sname);
error = EINVAL;
goto done;
}
/* Make a copy of the partition table to avoid alignment problems. */
memcpy(&dpcopy[0], cp + DOSPARTOFF, sizeof(dpcopy));
dp0 = &dpcopy[0];
/*
* Check for "Ontrack Diskmanager" or GPT. If a GPT is found in
* the first dos partition, ignore the rest of the MBR and go
* to GPT processing.
*/
for (dospart = 0, dp = dp0; dospart < NDOSPART; dospart++, dp++) {
if (dospart == 0 &&
(dp->dp_typ == DOSPTYP_PMBR || dp->dp_typ == DOSPTYP_GPT)) {
if (bootverbose)
kprintf(
"%s: Found GPT in slice #%d\n", sname, dospart + 1);
error = gptinit(dev, info, sspp);
goto done;
}
if (dp->dp_typ == DOSPTYP_ONTRACK) {
if (bootverbose)
kprintf(
"%s: Found \"Ontrack Disk Manager\" on this disk.\n", sname);
bp->b_flags |= B_INVAL | B_AGE;
brelse(bp);
mbr_offset = 63;
goto reread_mbr;
}
}
if (bcmp(dp0, historical_bogus_partition_table,
sizeof historical_bogus_partition_table) == 0 ||
bcmp(dp0, historical_bogus_partition_table_fixed,
sizeof historical_bogus_partition_table_fixed) == 0) {
#if 0
TRACE(("%s: invalid primary partition table: historical\n",
sname));
#endif /* 0 */
if (bootverbose)
kprintf(
"%s: invalid primary partition table: Dangerously Dedicated (ignored)\n",
sname);
error = EINVAL;
goto done;
}
/* Guess the geometry. */
/*
* TODO:
* Perhaps skip entries with 0 size.
* Perhaps only look at entries of type DOSPTYP_386BSD.
*/
max_ncyls = 0;
max_nsectors = 0;
max_ntracks = 0;
for (dospart = 0, dp = dp0; dospart < NDOSPART; dospart++, dp++) {
int ncyls;
int nsectors;
int ntracks;
ncyls = DPCYL(dp->dp_ecyl, dp->dp_esect) + 1;
if (max_ncyls < ncyls)
max_ncyls = ncyls;
nsectors = DPSECT(dp->dp_esect);
if (max_nsectors < nsectors)
max_nsectors = nsectors;
ntracks = dp->dp_ehd + 1;
if (max_ntracks < ntracks)
max_ntracks = ntracks;
}
/*
* Check that we have guessed the geometry right by checking the
* partition entries.
*/
/*
* TODO:
* As above.
* Check for overlaps.
* Check against d_secperunit if the latter is reliable.
*/
error = 0;
for (dospart = 0, dp = dp0; dospart < NDOSPART; dospart++, dp++) {
if (dp->dp_scyl == 0 && dp->dp_shd == 0 && dp->dp_ssect == 0
&& dp->dp_start == 0 && dp->dp_size == 0)
continue;
//sname = dsname(dev, dkunit(dev), BASE_SLICE + dospart,
// WHOLE_SLICE_PART, partname);
/*
* Temporarily ignore errors from this check. We could
* simplify things by accepting the table eariler if we
* always ignore errors here. Perhaps we should always
* accept the table if the magic is right but not let
* bad entries affect the geometry.
*/
check_part(sname, dp, mbr_offset, max_nsectors, max_ntracks,
mbr_offset);
}
if (error != 0)
goto done;
/*
* Accept the DOS partition table.
*
* Adjust the disk information structure with updated CHS
* conversion parameters, but only use values extracted from
* the primary partition table.
*
* NOTE! Regardless of our having to deal with this old cruft,
* we do not screw around with the info->d_media* parameters.
*/
secpercyl = (u_long)max_nsectors * max_ntracks;
if (secpercyl != 0 && mbr_offset == DOSBBSECTOR) {
info->d_secpertrack = max_nsectors;
info->d_nheads = max_ntracks;
info->d_secpercyl = secpercyl;
info->d_ncylinders = info->d_media_blocks / secpercyl;
}
/*
* We are passed a pointer to a suitably initialized minimal
* slices "struct" with no dangling pointers in it. Replace it
* by a maximal one. This usually oversizes the "struct", but
* enlarging it while searching for logical drives would be
* inconvenient.
*/
kfree(*sspp, M_DEVBUF);
ssp = dsmakeslicestruct(MAX_SLICES, info);
*sspp = ssp;
/* Initialize normal slices. */
sp = &ssp->dss_slices[BASE_SLICE];
for (dospart = 0, dp = dp0; dospart < NDOSPART; dospart++, dp++, sp++) {
sname = dsname(dev, dkunit(dev), BASE_SLICE + dospart,
WHOLE_SLICE_PART, partname);
(void)mbr_setslice(sname, info, sp, dp, mbr_offset);
}
ssp->dss_nslices = BASE_SLICE + NDOSPART;
/* Handle extended partitions. */
sp -= NDOSPART;
for (dospart = 0; dospart < NDOSPART; dospart++, sp++) {
if (sp->ds_type == DOSPTYP_EXTENDED ||
sp->ds_type == DOSPTYP_EXTENDEDX) {
mbr_extended(wdev, info, ssp,
sp->ds_offset, sp->ds_size, sp->ds_offset,
max_nsectors, max_ntracks, mbr_offset, 1);
}
}
/*
* mbr_extended() abuses ssp->dss_nslices for the number of slices
* that would be found if there were no limit on the number of slices
* in *ssp. Cut it back now.
*/
if (ssp->dss_nslices > MAX_SLICES)
ssp->dss_nslices = MAX_SLICES;
done:
bp->b_flags |= B_INVAL | B_AGE;
brelse(bp);
if (error == EINVAL)
error = 0;
return (error);
}
static
void
mbr_extended(cdev_t dev, struct disk_info *info, struct diskslices *ssp,
u_int64_t ext_offset, u_int64_t ext_size, u_int64_t base_ext_offset,
int nsectors, int ntracks, u_int64_t mbr_offset, int level)
{
struct buf *bp;
u_char *cp;
int dospart;
struct dos_partition *dp;
struct dos_partition dpcopy[NDOSPART];
u_int64_t ext_offsets[NDOSPART];
u_int64_t ext_sizes[NDOSPART];
char partname[2];
int slice;
char *sname;
struct diskslice *sp;
if (level >= 16) {
kprintf(
"%s: excessive recursion in search for slices; aborting search\n",
devtoname(dev));
return;
}
/* Read extended boot record. */
bp = geteblk((int)info->d_media_blksize);
bp->b_bio1.bio_offset = (off_t)ext_offset * info->d_media_blksize;
bp->b_bio1.bio_done = biodone_sync;
bp->b_bio1.bio_flags |= BIO_SYNC;
bp->b_bcount = info->d_media_blksize;
bp->b_cmd = BUF_CMD_READ;
bp->b_flags |= B_FAILONDIS;
dev_dstrategy(dev, &bp->b_bio1);
if (biowait(&bp->b_bio1, "mbrrd") != 0) {
diskerr(&bp->b_bio1, dev,
"reading extended partition table: error",
LOG_PRINTF, 0);
kprintf("\n");
goto done;
}
/* Weakly verify it. */
cp = bp->b_data;
if (cp[0x1FE] != 0x55 || cp[0x1FF] != 0xAA) {
sname = dsname(dev, dkunit(dev), WHOLE_DISK_SLICE, WHOLE_SLICE_PART,
partname);
if (bootverbose)
kprintf("%s: invalid extended partition table: no magic\n",
sname);
goto done;
}
/* Make a copy of the partition table to avoid alignment problems. */
memcpy(&dpcopy[0], cp + DOSPARTOFF, sizeof(dpcopy));
slice = ssp->dss_nslices;
for (dospart = 0, dp = &dpcopy[0]; dospart < NDOSPART;
dospart++, dp++) {
ext_sizes[dospart] = 0;
if (dp->dp_scyl == 0 && dp->dp_shd == 0 && dp->dp_ssect == 0
&& dp->dp_start == 0 && dp->dp_size == 0)
continue;
if (dp->dp_typ == DOSPTYP_EXTENDED ||
dp->dp_typ == DOSPTYP_EXTENDEDX) {
static char buf[32];
sname = dsname(dev, dkunit(dev), WHOLE_DISK_SLICE,
WHOLE_SLICE_PART, partname);
ksnprintf(buf, sizeof(buf), "%s", sname);
if (strlen(buf) < sizeof buf - 11)
strcat(buf, "<extended>");
check_part(buf, dp, base_ext_offset, nsectors,
ntracks, mbr_offset);
ext_offsets[dospart] = base_ext_offset + dp->dp_start;
ext_sizes[dospart] = dp->dp_size;
} else {
sname = dsname(dev, dkunit(dev), slice, WHOLE_SLICE_PART,
partname);
check_part(sname, dp, ext_offset, nsectors, ntracks,
mbr_offset);
if (slice >= MAX_SLICES) {
kprintf("%s: too many slices\n", sname);
slice++;
continue;
}
sp = &ssp->dss_slices[slice];
if (mbr_setslice(sname, info, sp, dp, ext_offset) != 0)
continue;
slice++;
}
}
ssp->dss_nslices = slice;
/* If we found any more slices, recursively find all the subslices. */
for (dospart = 0; dospart < NDOSPART; dospart++) {
if (ext_sizes[dospart] != 0) {
mbr_extended(dev, info, ssp, ext_offsets[dospart],
ext_sizes[dospart], base_ext_offset,
nsectors, ntracks, mbr_offset, ++level);
}
}
done:
bp->b_flags |= B_INVAL | B_AGE;
brelse(bp);
}