/* obclass - get the class of an object */
LVAL obclass(void)
{
LVAL self;
self = xlgaobject();
xllastarg();
return (getclass(self));
}
static void
printdata(size_t level, const void *v, size_t x, size_t l)
{
const uint8_t *p = v, *ep = p + l;
size_t ox;
char buf[128];
while (p + x < ep) {
const uint8_t *q;
uint8_t c = getclass(p[x]);
uint8_t t = gettype(p[x]);
ox = x;
if (x != 0)
printf("%.2x %.2x %.2x\n", p[x - 1], p[x], p[x + 1]);
uint32_t tag = gettag(p, &x, ep - p + x);
if (p + x >= ep)
break;
uint32_t len = getlength(p, &x, ep - p + x);
printf("%zu %zu-%zu %c,%c,%s,%u:", level, ox, x,
der_class[c], der_type[t],
der_tag(buf, sizeof(buf), tag), len);
q = p + x;
if (p + len > ep)
errx(EXIT_FAILURE, "corrupt der");
printtag(tag, q, len);
if (t != DER_TYPE_PRIMITIVE)
printdata(level + 1, p, x, len + x);
x += len;
}
}
/* obisa - does an object inherit from class? */
LVAL obisa(void)
{
LVAL self, cl, obcl;
self = xlgaobject();
cl = xlgaobject();
xllastarg();
obcl = getclass(self);
while (obcl) {
if (obcl == cl) return s_true;
obcl = getivar(obcl, SUPERCLASS);
}
return NIL;
}
/*
* insert_freenode - insert the freed block to the free list
*/
static void insert_freenode(void *bp)
{
size_t size = GET_SIZE(HDRP(bp));
void *root = getroot(getclass(size));
void *next_free_block_addr = (void *)*NEXTP(root);
PUT_ADDR(NEXTP(bp), *NEXTP(root));
PUT_ADDR(PREVP(bp), root);
PUT_ADDR(NEXTP(root), bp);
if (next_free_block_addr != NULL) {
PUT_ADDR(PREVP(next_free_block_addr), bp);
}
}
/* xsendmsg - send a message to an object */
LOCAL LVAL xsendmsg(LVAL obj, LVAL cls, LVAL sym)
{
LVAL msg=NULL,msgcls,method,val,p;
/* look for the message in the class or superclasses */
for (msgcls = cls; msgcls; ) {
/* lookup the message in this class */
for (p = getivar(msgcls,MESSAGES); p; p = cdr(p))
if ((msg = car(p)) && car(msg) == sym)
goto send_message;
/* look in class's superclass */
msgcls = getivar(msgcls,SUPERCLASS);
}
/* message not found */
xlerror("no method for this message",sym);
send_message:
/* insert the value for 'self' (overwrites message selector) */
*--xlargv = obj;
++xlargc;
/* invoke the method */
if ((method = cdr(msg)) == NULL)
xlerror("bad method",method);
switch (ntype(method)) {
case SUBR:
val = (*getsubr(method))();
break;
case CLOSURE:
if (gettype(method) != s_lambda)
xlerror("bad method",method);
val = evmethod(obj,msgcls,method);
break;
default:
xlerror("bad method",method);
}
/* after creating an object, send it the ":isnew" message */
if (car(msg) == k_new && val) {
xlprot1(val);
xsendmsg(val,getclass(val),k_isnew);
xlpop();
}
/* return the result value */
return (val);
}
int main()
{
char *query,*pptr;
char ftphost[MAX],email[MAX],dnsname[MAX],ipstring[20],genbuf[MAX];
unsigned char addr[4];
int ret=0,ipclass=0,inlib=0;
alarm(CGIALARM);
query=getenv(QUERYSTRING);
putHead();
strcpy(ftphost,"");
if(query && *query ){
while(query && *query){
if(!strncmp(query,"ftp=",4)) {
query+=4;
if((pptr=strchr(query,'&'))!=NULL) *pptr='\0'; /* set the NULL at end of string */
strncpy(ftphost,query,MAX-1);
*(ftphost+MAX-1)='\0';
} else if(!strncmp(query,"email=",6)) {
query+=6;
if((pptr=strchr(query,'&'))!=NULL) *pptr='\0'; /* set the NULL at end of string */
strncpy(email,query,MAX-1);
*(email+MAX-1)='\0';
}
query=strchr(query,'&');
if(query) query++;
}
if(strlen(ftphost)){
ret=getftpname(ftphost,dnsname,addr);
if(ret>-2){
sprintf(ipstring,"%d.%d.%d.%d",addr[0],addr[1],addr[2],addr[3]);
ipclass=getclass(addr);
if(ipclass<=2){ /* free IP, can search */
inlib=addftp(ipstring);
}
if(ret<3)/* fail on getting DNS name */
strcpy(dnsname,ftphost);
}else{
ipclass=4; /* out of CERNET */
strcpy(dnsname,ftphost);
}
showthank(dnsname,ipstring,ipclass,inlib);
}
}
putPage();
putEnd();
/* log submit */
sprintf(genbuf,"E-Mail:%s, Submit:'%s',dns:%s,ip:%s,class:%d",email,ftphost,dnsname,ipstring,ipclass);
Log(SUBMITLOGFILE,genbuf);
return(0);
}
/*
* insert_freenode - insert the freed block to the free list
*/
inline void insert_freenode(void *bp)
{
size_t size = GET_SIZE(HDRP(bp));
void *root = getroot(getclass(size));
void *nextp = next_free_blck(root);
void *prevp = root;
for (; nextp!=NULL && GET_SIZE(HDRP(nextp)) < size; prevp = nextp, nextp = (char *)next_free_blck(nextp)) {
}
PUT_ADDR(NEXTP(bp), nextp);
PUT_ADDR(PREVP(bp), prevp);
PUT_ADDR(NEXTP(prevp), bp);
if (nextp != NULL) {
PUT_ADDR(PREVP(nextp), bp);
}
}
/*
* This puts the class information in only. It could create a hybrid
* printer object to return, but that is problematic at best.
*/
papi_status_t
lpsched_class_configuration_to_attributes(service_t *svc, printer_t *p,
char *dest)
{
CLASS *tmp;
if ((svc == NULL) || (p == NULL))
return (PAPI_BAD_ARGUMENT);
/* get the configuration DB data */
if ((tmp = getclass(dest)) == NULL) {
detailed_error(svc,
gettext("unable to read configuration data"));
return (PAPI_DEVICE_ERROR);
}
/* name */
papiAttributeListAddLPString(&p->attributes, PAPI_ATTR_REPLACE,
"printer-name", tmp->name);
if (tmp->name != NULL) {
char uri[BUFSIZ];
snprintf(uri, sizeof (uri), "lpsched://localhost/printers/%s",
tmp->name);
papiAttributeListAddString(&p->attributes, PAPI_ATTR_REPLACE,
"printer-uri-supported", uri);
}
if (tmp->members != NULL) {
char **members = tmp->members;
int i;
for (i = 0; members[i] != NULL; i++)
papiAttributeListAddString(&p->attributes,
PAPI_ATTR_APPEND,
"member-names", members[i]);
}
freeclass(tmp);
return (PAPI_OK);
}
/* obshow - show the instance variables of an object */
LVAL obshow(void)
{
LVAL self,fptr,cls,names;
int ivtotal,n;
/* get self and the file pointer */
self = xlgaobject();
fptr = (moreargs() ? xlgetfile() : getvalue(s_stdout));
xllastarg();
/* get the object's class */
cls = getclass(self);
/* print the object and class */
xlputstr(fptr,"Object is ");
xlprint(fptr,self,TRUE);
xlputstr(fptr,", Class is ");
xlprint(fptr,cls,TRUE);
xlterpri(fptr);
/* print the object's instance variables */
for (; cls; cls = getivar(cls,SUPERCLASS)) {
names = getivar(cls,IVARS);
ivtotal = getivcnt(cls,IVARTOTAL);
for (n = ivtotal - getivcnt(cls,IVARCNT); n < ivtotal; ++n) {
xlputstr(fptr," ");
xlprint(fptr,car(names),TRUE);
xlputstr(fptr," = ");
xlprint(fptr,getivar(self,n),TRUE);
xlterpri(fptr);
names = cdr(names);
}
}
/* return the object */
return (self);
}
/* xsend - send a message to an object */
LVAL xsend(void)
{
LVAL obj;
obj = xlgaobject();
return (xsendmsg(obj,getclass(obj),xlgasymbol()));
}
/*
* The out of control system call
* This is audit kitchen sink aka auditadm, aka auditon
*/
int
auditctl(
int cmd,
caddr_t data,
int length)
{
int result;
switch (cmd) {
case A_GETAMASK:
case A_GETCOND:
case A_GETCAR:
case A_GETCLASS:
case A_GETCWD:
case A_GETKAUDIT:
case A_GETKMASK:
case A_GETPINFO:
case A_GETPINFO_ADDR:
case A_GETPOLICY:
case A_GETQCTRL:
case A_GETSTAT:
if (secpolicy_audit_getattr(CRED(), B_FALSE) != 0)
return (EPERM);
break;
default:
if (secpolicy_audit_config(CRED()) != 0)
return (EPERM);
break;
}
switch (cmd) {
case A_GETPOLICY:
result = getpolicy(data);
break;
case A_SETPOLICY:
result = setpolicy(data);
break;
case A_GETAMASK:
result = getamask(data);
break;
case A_SETAMASK:
result = setamask(data);
break;
case A_GETKMASK:
result = getkmask(data);
break;
case A_SETKMASK:
result = setkmask(data);
break;
case A_GETKAUDIT:
result = getkaudit(data, length);
break;
case A_SETKAUDIT:
result = setkaudit(data, length);
break;
case A_GETQCTRL:
result = getqctrl(data);
break;
case A_SETQCTRL:
result = setqctrl(data);
break;
case A_GETCWD:
result = getcwd(data, length);
break;
case A_GETCAR:
result = getcar(data, length);
break;
case A_GETSTAT:
result = getstat(data);
break;
case A_SETSTAT:
result = setstat(data);
break;
case A_SETUMASK:
result = setumask(data);
break;
case A_SETSMASK:
result = setsmask(data);
break;
case A_GETCOND:
result = getcond(data);
break;
case A_SETCOND:
result = setcond(data);
break;
case A_GETCLASS:
result = getclass(data);
break;
case A_SETCLASS:
result = setclass(data);
break;
case A_GETPINFO:
result = getpinfo(data);
break;
case A_GETPINFO_ADDR:
result = getpinfo_addr(data, length);
break;
case A_SETPMASK:
result = setpmask(data);
break;
default:
result = EINVAL;
break;
}
return (result);
}
void fastscan() {
struct methodchain *methodstack=NULL;
struct namer *namer=allocatenamer();
struct genhashtable *calltable=genallocatehashtable((int (*)(void *)) &hashmethod, (int (*)(void *,void *)) &comparemethod);
struct genhashtable *statictable=genallocatehashtable((int (*)(void *)) &hashmethod, (int (*)(void *,void *)) &comparemethod);
while(1) {
char *line=getline();
#ifdef DEBUG
printf("------------------------------------------------------\n");
#endif
if (line==0) {
outputinfo(namer, calltable,statictable);
return;
}
#ifdef DEBUG
printf("[%s]\n",line);
#endif
switch(line[0]) {
case 'C':
break;
case 'O':
break;
case 'N':
{
/* Natively created object...may not have pointer to it*/
char buf[1000];
sscanf(line,"NI: %s",buf);
getclass(namer,buf);
}
break;
case 'U':
{
/* New object*/
char buf[1000];
sscanf(line,"UI: %s",buf);
getclass(namer,buf);
}
break;
case 'K':
break;
case 'L':
/* Do Load */
{
struct localvars * lv=(struct localvars *) calloc(1, sizeof(struct localvars));
long long uid, objuid;
char fieldname[600], classname[600], fielddesc[600];
sscanf(line,"LF: %s %ld %s %lld %s %s %s %lld",lv->name,&lv->linenumber, lv->sourcename, &objuid, classname, fieldname, fielddesc, &uid);
getfield(namer,classname, fieldname,fielddesc);
}
break;
case 'G':
/* Do Array Load */
break;
case 'M':
/* Mark Local*/
break;
case 'I':
/* Enter Method*/
{
struct methodchain* methodchain=(struct methodchain *) calloc(1,sizeof(struct methodchain));
char classname[600], methodname[600],signature[600];
int isStatic;
sscanf(line,"IM: %s %s %s %d", classname, methodname, signature, &isStatic);
methodchain->method=getmethod(namer, classname, methodname, signature);
methodchain->caller=methodstack;
if (!gencontains(statictable, methodchain->method)) {
int * staticflag=(int *)malloc(sizeof (int));
*staticflag=isStatic;
genputtable(statictable, methodchain->method, staticflag);
}
if (methodstack!=NULL) {
if (!gencontains(calltable, methodchain->method)) {
struct methodchain *mc=(struct methodchain *) calloc(1,sizeof(struct methodchain));
mc->method=methodstack->method;
genputtable(calltable, methodchain->method, mc);
} else {
struct methodchain *tosearch=(struct methodchain *)gengettable(calltable, methodchain->method);
while(tosearch->method!=methodstack->method) {
if (tosearch->caller==NULL) {
struct methodchain *mc=(struct methodchain *) calloc(1,sizeof(struct methodchain));
mc->method=methodstack->method;
tosearch->caller=mc;
break;
}
tosearch=tosearch->caller;
}
}
}
methodstack=methodchain;
}
break;
case 'R':
/* Return from method */
{
struct methodchain* caller=methodstack->caller;
free(methodstack);
methodstack=caller;
}
break;
case 'F':
/* Field Assignment */
{
long long suid;
long long duid;
char classname[1000];
char fieldname[1000];
char descname[1000];
sscanf(line,"FA: %lld %s %s %s %lld", &suid, classname, fieldname, descname, &duid);
getfield(namer, classname, fieldname, descname);
}
break;
case 'A':
/* Array Assignment */
{
long long suid;
long long duid;
long index;
sscanf(line,"AA: %lld %ld %lld", &suid, &index, &duid);
}
break;
}
free(line);
}
}
