void ComputeGain(Geometry geo, Mode *ms, int Nh){
VecSet(geo->vH, 0.0);
Vecfun H, f;
CreateVecfun(&H, geo->vH);
CreateVecfun(&f, geo->vf);
int i, ih;
for(ih=0; ih<Nh; ih++){
Mode m = ms[ih];
double mc = get_c(m);
// do not change this from vscratch[3], or the hack below for single mode Column derivative will fail!
VecDotMedium(geo, m->vpsi, m->vpsi, geo->vscratch[3], geo->vMscratch[0]);
Vecfun psisq;
CreateVecfun(&psisq ,geo->vscratch[3]);
for(i=H.ns; i<H.ne; i++){
if(valr(&f, i) == 0.0) continue;
setr(&H, i, valr(&H, i) + sqr(mc) * valr(&psisq, i) ) ;
}
DestroyVecfun(&psisq);
}
if(geo->interference != 0.0 && Nh == 2){
// does not affect single mode case
VecDotMedium(geo, ms[0]->vpsi, ms[1]->vpsi, geo->vscratch[3], geo->vMscratch[0]);
Vec Ipsi = geo->vscratch[5];
TimesI( geo, ms[0]->vpsi, Ipsi);
VecDotMedium(geo, ms[1]->vpsi, Ipsi, geo->vscratch[6], geo->vMscratch[0]);
// 2 c1 c2 Re[ exp(i thet) psi1* x psi2) ]
// term in square bracket is (cos thet + i sin thet ) x
// ( E1R . E2R + E1I . E2I ) + i ( E1R . E2I - E1I . E2R )
// vscratch[3] and vscratch[6] are the real and imaginary parts of this last line
double costh = cos(geo->interference), sinth = sin(geo->interference);
VecScale(geo->vscratch[6], -sinth);
VecAXPY( geo->vscratch[6], costh, geo->vscratch[3]);
// now vscratch[6] = Re[ ... ]
double mc[2] = {get_c(ms[0]), get_c(ms[1]) };
Vecfun psi_int;
CreateVecfun(&psi_int ,geo->vscratch[6]);
for(i=H.ns; i<H.ne; i++){
if(valr(&f, i) == 0.0) continue;
setr(&H, i, valr(&H, i) + 2.0*mc[0]*mc[1] * valr(&psi_int, i) ) ;
}
DestroyVecfun(&psi_int);
}
for(i=H.ns; i<H.ne; i++)
setr(&H, i, 1.0 / (1.0 + valr(&H, i) ) );
// for plotting purposes, don't check if valr(&f, i)==0 here
DestroyVecfun(&H);
DestroyVecfun(&f);
}
Warp::Warp(int width, int height) :
c(width * 0.5f, height * 0.5f),
f(float(max(width, height)))
{
setr(Vector3f(0.0f, 0.0f, 0.0f));
sett(Vector3f(0.0f, 0.0f, 0.0f));
}
void Warp::steepest(Matrix<float, 6, 1> parameters)
{
float rx = r.x() + parameters(0);
float ry = r.y() + parameters(1);
float rz = r.z() + parameters(2);
float tx = t.x() + parameters(3);
float ty = t.y() + parameters(4);
float tz = t.z() + parameters(5);
setr(Vector3f(rx, ry, rz));
sett(Vector3f(tx, ty, tz));
}
void rpcbuf::finish_request() {
int length = pptr() - rptr();
if (rptr() && length > 0) {
pbump(-length);
mystream().width(FIELDWIDTH);
mystream() << length;
if (_actualWidth != pptr() - rptr()) {
error("rpcbuf::finish_request: length field's width changed");
}
pbump(length - (pptr() - rptr()));
}
setr(nil);
}
PafColor& PafColor::makeDepthmapClassic( double field, double blue, double red )
{
m_color = 0xff000000; // set alpha to 255, solid colour
double green = blue + (red-blue) / 10.0;
// NB previously included colour muting: the 1.0 was originally 0.9 to mute the colours slightly
if (field >= 0.0 && field < blue) {
setr(htmlByte(0.5 * (blue - field)/blue * 1.0));
// Quick mod - TV
#if defined(_WIN32)
setb(unsigned char(0xFF));
#else
setb((unsigned char)(0xFF));
#endif
}
int rpcbuf::start_request() {
if (!_mystream || !_opened || allocate() == EOF) {
return EOF;
}
finish_request();
setr(pptr());
const int length = 0;
mystream().width(FIELDWIDTH);
mystream() << length;
_actualWidth = pptr() - rptr();
return 0;
}
boolean rpcbuf::expand_p() {
int newsize = (epptr() - pbase()) * 2;
char* put = new char[newsize];
if (!put) {
return false;
}
int nwaiting = out_waiting();
Memory::copy(pbase(), put, nwaiting);
delete pbase();
setp(put, put + newsize);
pbump(nwaiting);
setr(put);
return true;
}
void creatures::clear()
{
// clear all and set default to man
rmset(objects, 0, sizeof(objects));
for(int i = FirstCreature; i<=LastCreature; i++)
{
setr(i, Strenght, 5);
setr(i, Perception, 5);
setr(i, Endurance, 5);
setr(i, Charisma, 5);
setr(i, Intellegence, 5);
setr(i, Agility, 5);
setr(i, Luck, 5);
set(i, Age, 25);
}
rmset(inventories, 0, sizeof(inventories));
}
void TMOGUIToneSlider::setlog()
{
bLog = true;
switch (iMode)
{
case 0:
setl();
break;
case 1:
setr();
break;
case 2:
setg();
break;
case 3:
setb();
break;
}
update();
}
void validate_current_settings()
{
int rlim_needed;
if (cur_limits.rlim_cur < 4096) {
printf("Current rlimit value for POSIX message queue bytes is "
"unreasonably low,\nincreasing.\n\n");
cur_limits.rlim_cur = 8192;
cur_limits.rlim_max = 16384;
setr(RLIMIT_MSGQUEUE, &cur_limits);
}
if (default_settings) {
rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
2 * sizeof(void *));
if (rlim_needed > cur_limits.rlim_cur) {
printf("Temporarily lowering default queue parameters "
"to something that will work\n"
"with the current rlimit values.\n\n");
set(def_msgs, 10);
cur_def_msgs = 10;
set(def_msgsize, 128);
cur_def_msgsize = 128;
}
} else {
rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
2 * sizeof(void *));
if (rlim_needed > cur_limits.rlim_cur) {
printf("Temporarily lowering maximum queue parameters "
"to something that will work\n"
"with the current rlimit values in case this is "
"a kernel that ties the default\n"
"queue parameters to the maximum queue "
"parameters.\n\n");
set(max_msgs, 10);
cur_max_msgs = 10;
set(max_msgsize, 128);
cur_max_msgsize = 128;
}
}
}
TMOGUIAdjust::TMOGUIAdjust(QWidget* parent, const char * name):
QFrame(parent, name)
{
iMode = 0;
pValues = 0;
bLog = true;
bUpdate = false;
setFrameStyle( QFrame::Panel | QFrame::Sunken );
QGridLayout *pLayout = new QGridLayout(this, 8, 4);
pLayout->setColStretch(0,0);
pLayout->setColStretch(1,1);
pLayout->setColStretch(2,0);
pLayout->setColStretch(3,0);
pLayout->addColSpacing(2,20);
QSlider *pSlider = new QSlider(this, "HistoSlider");
pSlider->setFixedSize(16,64);
pSlider->setRange(-50, 50);
pSlider->setValue(0);
pSlider->setOrientation(Vertical);
pSlider->setTickmarks(QSlider::Right);
pSlider->setTickInterval(10);
pLayout->addMultiCellWidget(pSlider, 0, 3, 0, 0);
pHisto = new TMOGUIHisto(this, "Histogram");
pLayout->addMultiCellWidget(pHisto, 0, 3, 1, 1, AlignBottom);
pLayout->addRowSpacing(4, 2);
pToneSlider = new TMOGUIToneSlider(this, "ToneSlider");
pLayout->addWidget(pToneSlider, 5, 1);
pRed = new QPushButton(this, "RedButton");
pRed->setFlat(true);
pRed->setFixedSize(16,16);
pRed->setPixmap(*TMOResource::pResource->IconRed->pixmap());
QToolTip::add(pRed, "Select Red Channel");
pLayout->addWidget(pRed, 0, 2, AlignCenter);
pGreen = new QPushButton(this, "GreenButton");
pGreen->setFlat(true);
pGreen->setFixedSize(16,16);
pGreen->setPixmap(*TMOResource::pResource->IconGreen->pixmap());
QToolTip::add(pGreen, "Select Green Channel");
pLayout->addWidget(pGreen, 1, 2, AlignCenter);
pBlue = new QPushButton(this, "BlueButton");
pBlue->setFlat(true);
pBlue->setFixedSize(16,16);
pBlue->setPixmap(*TMOResource::pResource->IconBlue->pixmap());
QToolTip::add(pBlue, "Select Blue Channel");
pLayout->addWidget(pBlue, 2, 2, AlignCenter);
pLum = new QPushButton(this, "LumButton");
pLum->setFlat(true);
pLum->setFixedSize(16,16);
pLum->setPixmap(*TMOResource::pResource->IconLumDown->pixmap());
QToolTip::add(pLum, "Select Luminance");
pLayout->addWidget(pLum, 3, 2, AlignCenter);
pLinear = new QPushButton(this, "LinearButton");
pLinear->setFlat(true);
pLinear->setFixedSize(32,32);
pLinear->setPixmap(*TMOResource::pResource->IconLin->pixmap());
QToolTip::add(pLinear, "View In Linear Distribution");
pLayout->addMultiCellWidget(pLinear, 0, 1, 3, 3, AlignCenter);
pLog = new QPushButton(this, "LogarithmicButton");
pLog->setFlat(true);
pLog->setFixedSize(32,32);
pLog->setPixmap(*TMOResource::pResource->IconLogDown->pixmap());
QToolTip::add(pLog, "View In Logarithmic Distribution");
pLayout->addMultiCellWidget(pLog, 2, 3, 3, 3, AlignCenter);
pLayout->addRowSpacing(6, 2);
QHBoxLayout* hbox = new QHBoxLayout();
QLabel* pLabel = new QLabel(this, "BlackLabel");
pLabel->setPixmap(*TMOResource::pResource->IconBlack->pixmap());
pLabel->setFrameStyle( QFrame::Panel | QFrame::Sunken );
hbox->addWidget(pLabel);
pBlack = new QLineEdit(this, "EditBlack");
pBlack->setAlignment(Qt::AlignRight);
pBlack->setFixedWidth(72);
hbox->addWidget(pBlack);
hbox->insertStretch(-1,1);
pLabel = new QLabel(this, "GammaLabel");
pLabel->setPixmap(*TMOResource::pResource->IconGamma->pixmap());
pLabel->setFrameStyle( QFrame::Panel | QFrame::Sunken );
hbox->addWidget(pLabel);
pGamma = new QLineEdit(this, "EditGamma");
pGamma->setAlignment(Qt::AlignRight);
pGamma->setFixedWidth(72);
hbox->addWidget(pGamma);
hbox->insertStretch(-1,1);
pLabel = new QLabel(this, "WhiteLabel");
pLabel->setPixmap(*TMOResource::pResource->IconWhite->pixmap());
pLabel->setFrameStyle( QFrame::Panel | QFrame::Sunken );
hbox->addWidget(pLabel);
pWhite = new QLineEdit(this, "EditWhite");
pWhite->setAlignment(Qt::AlignRight);
pWhite->setFixedWidth(72);
hbox->addWidget(pWhite);
pLayout->addLayout(hbox, 7, 1);
connect (pSlider, SIGNAL(sliderMoved(int)), this, SLOT(scalechanged(int)));
connect (pLinear, SIGNAL(clicked()), pHisto, SLOT(setlinear()));
connect (pLog, SIGNAL(clicked()), pHisto, SLOT(setlog()));
connect (pRed, SIGNAL(clicked()), pHisto, SLOT(setr()));
connect (pGreen, SIGNAL(clicked()), pHisto, SLOT(setg()));
connect (pBlue, SIGNAL(clicked()), pHisto, SLOT(setb()));
connect (pLum, SIGNAL(clicked()), pHisto, SLOT(setl()));
connect (pLinear, SIGNAL(clicked()), pToneSlider, SLOT(setlinear()));
connect (pLog, SIGNAL(clicked()), pToneSlider, SLOT(setlog()));
connect (pRed, SIGNAL(clicked()), pToneSlider, SLOT(setr()));
connect (pGreen, SIGNAL(clicked()), pToneSlider, SLOT(setg()));
connect (pBlue, SIGNAL(clicked()), pToneSlider, SLOT(setb()));
connect (pLum, SIGNAL(clicked()), pToneSlider, SLOT(setl()));
connect (pRed, SIGNAL(clicked()), this, SLOT(setr()));
connect (pGreen, SIGNAL(clicked()), this, SLOT(setg()));
connect (pBlue, SIGNAL(clicked()), this, SLOT(setb()));
connect (pLum, SIGNAL(clicked()), this, SLOT(setl()));
connect (pBlack, SIGNAL(textChanged(const QString &)), this, SLOT(setblack(const QString &)));
connect (pWhite, SIGNAL(textChanged(const QString &)), this, SLOT(setwhite(const QString &)));
connect (pGamma, SIGNAL(textChanged(const QString &)), this, SLOT(setgamma(const QString &)));
connect (pBlack, SIGNAL(returnPressed()), this, SLOT(updateall()));
connect (pWhite, SIGNAL(returnPressed()), this, SLOT(updateall()));
connect (pGamma, SIGNAL(returnPressed()), this, SLOT(updateall()));
connect (pLinear, SIGNAL(clicked()), this, SLOT(setlinear()));
connect (pLog, SIGNAL(clicked()), this, SLOT(setlog()));
}
streampos rpcbuf::seekoff(streamoff offset, ios::seek_dir dir, int mode) {
#else
streampos rpcbuf::seekoff(streamoff offset, seek_dir dir, int mode) {
#endif
if (!_opened || !gptr()) {
return EOF;
}
if (offset != 0 || dir != ios::cur || mode != ios::in) {
return EOF;
}
return (streampos)gptr();
}
// Refuse any attempt to set the buffers for storing incoming and
// outgoing RPC requests because we need the ability to dynamically
// expand the buffers' sizes.
streambuf* rpcbuf::setbuf(char*, int) {
return nil;
}
// Dynamically allocate two separate buffers for storing incoming and
// outgoing RPC requests. Allocating separate buffers for the get and
// put areas makes it easier to expand either area later if necessary.
int rpcbuf::doallocate() {
const int RPCBUFSIZE = 2032;
char* get = new char[RPCBUFSIZE];
if (!get) {
error("rpcbuf::doallocate: out of memory");
return EOF;
}
setb(get, get + RPCBUFSIZE, true);
setg(get, get, get);
char* put = new char[RPCBUFSIZE];
if (!put) {
error("rpcbuf::doallocate: out of memory");
return EOF;
}
setp(put, put + RPCBUFSIZE);
setr(nil);
return 0;
}
// Expand the get area to make room for a large incoming request.
boolean rpcbuf::expand_g(int newsize) {
char* get = new char[newsize];
if (!get) {
return false;
}
int navail = in_avail();
Memory::copy(gptr(), get, navail);
delete eback();
setb(get, get + newsize, true);
setg(get, get, get + navail);
return true;
}
Geometry CreateGeometry(int N[3], double h[3], int Npml[3], int Nc, int LowerPML, double *eps, double *epsI, double *fprof, double wa, double y){
int i;
Geometry geo = (Geometry) malloc(sizeof(struct Geometry_s));
geo->Nc = Nc;
geo->LowerPML = LowerPML;
geo->interference = 0.0; // default no interference
for(i=0; i<3; i++){
geo->h[i] = h[i];
geo->Npml[i] = Npml[i];
}
CreateGrid(&geo->gN, N, geo->Nc, 2);
CreateGrid(&geo->gM, N, 1, 1); // 3/3/14: set M = N as per Steven
CreateVec(2*Nxyzc(geo)+2, &geo->vepspml);
int manual_epspml = 0;
PetscOptionsGetInt(PETSC_NULL,PETSC_NULL,"-manual_epspml", &manual_epspml, NULL);
if(manual_epspml == 0){
Vecfun pml;
CreateVecfun(&pml,geo->vepspml);
for(i=pml.ns; i<pml.ne; i++){
Point p;
CreatePoint_i(&p, i, &geo->gN);
project(&p, 3);
dcomp eps_geoal;
eps_geoal = pmlval(xyzc(&p), N, geo->Npml, geo->h, geo->LowerPML, 0);
setr(&pml, i, p.ir? cimag(eps_geoal) : creal(eps_geoal) );
}
DestroyVecfun(&pml);
}
CreateVec(Mxyz(geo), &geo->vMscratch[0]);
for(i=0; i<SCRATCHNUM; i++){
geo->vNhscratch[i] = 0; // allows checking whether vN created or not
if(i>0)VecDuplicate(geo->vMscratch[0], &geo->vMscratch[i]);
}
double *scratch;
int ms, me;
VecGetOwnershipRange(geo->vMscratch[0], &ms, &me);
if( !manual_epspml){
VecGetArray(geo->vMscratch[0], &scratch);
for(i=ms; i<me;i++)
scratch[i-ms] = eps[i-ms];
VecRestoreArray(geo->vMscratch[0], &scratch);
}
CreateVec(2*Nxyzc(geo)+2, &geo->vH);
VecDuplicate(geo->vH, &geo->veps);
VecDuplicate(geo->vH, &geo->vIeps);
for(i=0; i<SCRATCHNUM; i++) VecDuplicate(geo->vH, &geo->vscratch[i]);
VecSet(geo->vH, 1.0);
if( !manual_epspml){
VecShift(geo->vMscratch[0], -1.0); //hack, for background dielectric
InterpolateVec(geo, geo->vMscratch[0], geo->vscratch[1]);
VecShift(geo->vscratch[1], 1.0);
VecPointwiseMult(geo->veps, geo->vscratch[1], geo->vepspml);
if(epsI != NULL){ // imaginary part of passive dielectric
VecGetArray(geo->vMscratch[0], &scratch);
for(i=ms; i<me; i++){
scratch[i-ms] = epsI[i-ms];
}
VecRestoreArray(geo->vMscratch[0], &scratch);
InterpolateVec(geo, geo->vMscratch[0], geo->vscratch[1]);
VecPointwiseMult(geo->vscratch[1], geo->vscratch[1], geo->vepspml);
TimesI(geo, geo->vscratch[1], geo->vscratch[2]);
VecAXPY(geo->veps, 1.0, geo->vscratch[2]);
}
}
if(manual_epspml){
char epsManualfile[PETSC_MAX_PATH_LEN];
PetscOptionsGetString(PETSC_NULL,PETSC_NULL,"-epsManualfile", epsManualfile, PETSC_MAX_PATH_LEN, NULL);
FILE *fp = fopen(epsManualfile, "r");
ReadVectorC(fp, 2*Nxyzc(geo)+2, geo->veps);
// 07/11/15: if manual_epspml, then directly read in the Nxyzcr+2 vector
fclose(fp);
}
TimesI(geo, geo->veps, geo->vIeps);
// vIeps for convenience only, make sure to update it later if eps ever changes!
geo->D = 0.0;
geo->wa = wa;
geo->y = y;
VecDuplicate(geo->veps, &geo->vf);
VecDuplicate(geo->vMscratch[0], &geo->vfM);
VecGetArray(geo->vfM, &scratch);
for(i=ms; i<me;i++)
scratch[i-ms] = fprof[i-ms];
VecRestoreArray(geo->vfM, &scratch);
InterpolateVec(geo, geo->vfM, geo->vf);
return geo;
}
int main(int argc, char *argv[])
{
struct mq_attr attr, result;
if (argc != 2) {
fprintf(stderr, "Must pass a valid queue name\n\n");
fprintf(stderr, usage, argv[0]);
exit(1);
}
if (*argv[1] == '/')
queue_path = strdup(argv[1]);
else {
queue_path = malloc(strlen(argv[1]) + 2);
if (!queue_path) {
perror("malloc()");
exit(1);
}
queue_path[0] = '/';
queue_path[1] = 0;
strcat(queue_path, argv[1]);
}
if (getuid() != 0) {
fprintf(stderr, "Not running as root, but almost all tests "
"require root in order to modify\nsystem settings. "
"Exiting.\n");
exit(1);
}
/* Find out what files there are for us to make tweaks in */
def_msgs = fopen(DEF_MSGS, "r+");
def_msgsize = fopen(DEF_MSGSIZE, "r+");
max_msgs = fopen(MAX_MSGS, "r+");
max_msgsize = fopen(MAX_MSGSIZE, "r+");
if (!max_msgs)
shutdown(2, "Failed to open msg_max", __LINE__);
if (!max_msgsize)
shutdown(2, "Failed to open msgsize_max", __LINE__);
if (def_msgs || def_msgsize)
default_settings = 1;
/* Load up the current system values for everything we can */
getr(RLIMIT_MSGQUEUE, &saved_limits);
cur_limits = saved_limits;
if (default_settings) {
saved_def_msgs = cur_def_msgs = get(def_msgs);
saved_def_msgsize = cur_def_msgsize = get(def_msgsize);
}
saved_max_msgs = cur_max_msgs = get(max_msgs);
saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
/* Tell the user our initial state */
printf("\nInitial system state:\n");
printf("\tUsing queue path:\t\t%s\n", queue_path);
printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", saved_limits.rlim_cur);
printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", saved_limits.rlim_max);
printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
if (default_settings) {
printf("\tDefault Message Size:\t\t%d\n", saved_def_msgsize);
printf("\tDefault Queue Size:\t\t%d\n", saved_def_msgs);
} else {
printf("\tDefault Message Size:\t\tNot Supported\n");
printf("\tDefault Queue Size:\t\tNot Supported\n");
}
printf("\n");
validate_current_settings();
printf("Adjusted system state for testing:\n");
printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", cur_limits.rlim_cur);
printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", cur_limits.rlim_max);
printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
if (default_settings) {
printf("\tDefault Message Size:\t\t%d\n", cur_def_msgsize);
printf("\tDefault Queue Size:\t\t%d\n", cur_def_msgs);
}
printf("\n\nTest series 1, behavior when no attr struct "
"passed to mq_open:\n");
if (!default_settings) {
test_queue(NULL, &result);
printf("Given sane system settings, mq_open without an attr "
"struct succeeds:\tPASS\n");
if (result.mq_maxmsg != cur_max_msgs ||
result.mq_msgsize != cur_max_msgsize) {
printf("Kernel does not support setting the default "
"mq attributes,\nbut also doesn't tie the "
"defaults to the maximums:\t\t\tPASS\n");
} else {
set(max_msgs, ++cur_max_msgs);
set(max_msgsize, ++cur_max_msgsize);
test_queue(NULL, &result);
if (result.mq_maxmsg == cur_max_msgs &&
result.mq_msgsize == cur_max_msgsize)
printf("Kernel does not support setting the "
"default mq attributes and\n"
"also ties system wide defaults to "
"the system wide maximums:\t\t"
"FAIL\n");
else
printf("Kernel does not support setting the "
"default mq attributes,\n"
"but also doesn't tie the defaults to "
"the maximums:\t\t\tPASS\n");
}
} else {
printf("Kernel supports setting defaults separately from "
"maximums:\t\tPASS\n");
/*
* While we are here, go ahead and test that the kernel
* properly follows the default settings
*/
test_queue(NULL, &result);
printf("Given sane values, mq_open without an attr struct "
"succeeds:\t\tPASS\n");
if (result.mq_maxmsg != cur_def_msgs ||
result.mq_msgsize != cur_def_msgsize)
printf("Kernel supports setting defaults, but does "
"not actually honor them:\tFAIL\n\n");
else {
set(def_msgs, ++cur_def_msgs);
set(def_msgsize, ++cur_def_msgsize);
/* In case max was the same as the default */
set(max_msgs, ++cur_max_msgs);
set(max_msgsize, ++cur_max_msgsize);
test_queue(NULL, &result);
if (result.mq_maxmsg != cur_def_msgs ||
result.mq_msgsize != cur_def_msgsize)
printf("Kernel supports setting defaults, but "
"does not actually honor them:\t"
"FAIL\n");
else
printf("Kernel properly honors default setting "
"knobs:\t\t\t\tPASS\n");
}
set(def_msgs, cur_max_msgs + 1);
cur_def_msgs = cur_max_msgs + 1;
set(def_msgsize, cur_max_msgsize + 1);
cur_def_msgsize = cur_max_msgsize + 1;
if (cur_def_msgs * (cur_def_msgsize + 2 * sizeof(void *)) >=
cur_limits.rlim_cur) {
cur_limits.rlim_cur = (cur_def_msgs + 2) *
(cur_def_msgsize + 2 * sizeof(void *));
cur_limits.rlim_max = 2 * cur_limits.rlim_cur;
setr(RLIMIT_MSGQUEUE, &cur_limits);
}
if (test_queue_fail(NULL, &result)) {
if (result.mq_maxmsg == cur_max_msgs &&
result.mq_msgsize == cur_max_msgsize)
printf("Kernel properly limits default values "
"to lesser of default/max:\t\tPASS\n");
else
printf("Kernel does not properly set default "
"queue parameters when\ndefaults > "
"max:\t\t\t\t\t\t\t\tFAIL\n");
} else
printf("Kernel fails to open mq because defaults are "
"greater than maximums:\tFAIL\n");
set(def_msgs, --cur_def_msgs);
set(def_msgsize, --cur_def_msgsize);
cur_limits.rlim_cur = cur_limits.rlim_max = cur_def_msgs *
cur_def_msgsize;
setr(RLIMIT_MSGQUEUE, &cur_limits);
if (test_queue_fail(NULL, &result))
printf("Kernel creates queue even though defaults "
"would exceed\nrlimit setting:"
"\t\t\t\t\t\t\t\tFAIL\n");
else
printf("Kernel properly fails to create queue when "
"defaults would\nexceed rlimit:"
"\t\t\t\t\t\t\t\tPASS\n");
}
/*
* Test #2 - open with an attr struct that exceeds rlimit
*/
printf("\n\nTest series 2, behavior when attr struct is "
"passed to mq_open:\n");
cur_max_msgs = 32;
cur_max_msgsize = cur_limits.rlim_max >> 4;
set(max_msgs, cur_max_msgs);
set(max_msgsize, cur_max_msgsize);
attr.mq_maxmsg = cur_max_msgs;
attr.mq_msgsize = cur_max_msgsize;
if (test_queue_fail(&attr, &result))
printf("Queue open in excess of rlimit max when euid = 0 "
"succeeded:\t\tFAIL\n");
else
printf("Queue open in excess of rlimit max when euid = 0 "
"failed:\t\tPASS\n");
attr.mq_maxmsg = cur_max_msgs + 1;
attr.mq_msgsize = 10;
if (test_queue_fail(&attr, &result))
printf("Queue open with mq_maxmsg > limit when euid = 0 "
"succeeded:\t\tPASS\n");
else
printf("Queue open with mq_maxmsg > limit when euid = 0 "
"failed:\t\tFAIL\n");
attr.mq_maxmsg = 1;
attr.mq_msgsize = cur_max_msgsize + 1;
if (test_queue_fail(&attr, &result))
printf("Queue open with mq_msgsize > limit when euid = 0 "
"succeeded:\t\tPASS\n");
else
printf("Queue open with mq_msgsize > limit when euid = 0 "
"failed:\t\tFAIL\n");
attr.mq_maxmsg = 65536;
attr.mq_msgsize = 65536;
if (test_queue_fail(&attr, &result))
printf("Queue open with total size > 2GB when euid = 0 "
"succeeded:\t\tFAIL\n");
else
printf("Queue open with total size > 2GB when euid = 0 "
"failed:\t\t\tPASS\n");
seteuid(99);
attr.mq_maxmsg = cur_max_msgs;
attr.mq_msgsize = cur_max_msgsize;
if (test_queue_fail(&attr, &result))
printf("Queue open in excess of rlimit max when euid = 99 "
"succeeded:\t\tFAIL\n");
else
printf("Queue open in excess of rlimit max when euid = 99 "
"failed:\t\tPASS\n");
attr.mq_maxmsg = cur_max_msgs + 1;
attr.mq_msgsize = 10;
if (test_queue_fail(&attr, &result))
printf("Queue open with mq_maxmsg > limit when euid = 99 "
"succeeded:\t\tFAIL\n");
else
printf("Queue open with mq_maxmsg > limit when euid = 99 "
"failed:\t\tPASS\n");
attr.mq_maxmsg = 1;
attr.mq_msgsize = cur_max_msgsize + 1;
if (test_queue_fail(&attr, &result))
printf("Queue open with mq_msgsize > limit when euid = 99 "
"succeeded:\t\tFAIL\n");
else
printf("Queue open with mq_msgsize > limit when euid = 99 "
"failed:\t\tPASS\n");
attr.mq_maxmsg = 65536;
attr.mq_msgsize = 65536;
if (test_queue_fail(&attr, &result))
printf("Queue open with total size > 2GB when euid = 99 "
"succeeded:\t\tFAIL\n");
else
printf("Queue open with total size > 2GB when euid = 99 "
"failed:\t\t\tPASS\n");
shutdown(0,"",0);
}
int callprivate(int a) {
return setr(a);
}