/*=========================================================================*/
void SLPDDatabaseAge(int seconds)
/* Agea the database entries and clears new and deleted entry lists */
/* */
/* seconds (IN) the number of seconds to age each entry by */
/* */
/* Returns - None */
/*=========================================================================*/
{
SLPDDatabaseEntry* entry;
SLPDDatabaseEntry* del = 0;
/* Age the database */
entry = (SLPDDatabaseEntry*)G_DatabaseList.head;
while(entry)
{
/* don't age services with lifetime > SLP_LIFETIME_MAXIMUM */
if(entry->lifetime < SLP_LIFETIME_MAXIMUM)
{
entry->lifetime = entry->lifetime - seconds;
if(entry->lifetime <= 0)
{
del = entry;
}
}
entry = (SLPDDatabaseEntry*)entry->listitem.next;
if(del)
{
FreeEntry((SLPDDatabaseEntry*)SLPListUnlink(&G_DatabaseList,(SLPListItem*)del));
del = 0;
}
}
}
/*-------------------------------------------------------------------------*/
void FreeAllEntries(SLPList* list)
/*-------------------------------------------------------------------------*/
{
while(list->count)
{
FreeEntry((SLPDDatabaseEntry*)SLPListUnlink(list,list->head));
}
}
int DfsInodeDelete(int handle) {
int i;
dfs_block indirect_table;
uint32 *table;
// printf("In DfsInodeDelete\n");
if (sb.valid == 0){
printf("File system not open!\n");
return DFS_FAIL;
}
if((handle<0)||(handle>DFS_INODE_MAX_NUM)){
printf("Invalid inode handle = %d\n",handle);
return DFS_FAIL;
}
if(inodes[handle].inuse == 0){
printf("Inode not allocated!\n");
return DFS_FAIL;
}
LockHandleAcquire(lock_inode);
//Free direct table then check if there is indirect address
for(i=0;i<10;i++){
if(inodes[handle].direct[i]!=0){
if(DfsFreeBlock((int)inodes[handle].direct[i])==DFS_FAIL){
printf("Cannot free blocks in direct table!\n");
return DFS_FAIL;
}
inodes[handle].direct[i]=0;
}
}
//Free the indirect table
if(inodes[handle].indirect != 0){
table =(uint32 *)(&indirect_table);
DfsReadBlock(inodes[handle].indirect,&indirect_table);
for(i=0;i<(sb.filesys_blocksize)/sizeof(uint32);i++){
if(table[i]!=0){
if (DfsFreeBlock((int)table[i])== DFS_FAIL){
printf("Cannot free blocks in indirect table\n");
return DFS_FAIL;
}
}
}
if(DfsFreeBlock((int)inodes[handle].indirect)==DFS_FAIL){
printf("Cannot free blocks in indirect table\n");
}
inodes[handle].indirect=0;
}
FreeEntry(handle);
inodes[handle].filesize = 0;
// for(i=0;i< FILENAME_LENGTH;i++){
// inodes[handle].filename[i]='\0';
// }
inodes[handle].permission = 0;
inodes[handle].type = 0;
inodes[handle].ownerid = 0;
inodes[handle].inuse = 0;
LockHandleRelease(lock_inode);
return DFS_SUCCESS;
}
/*
* Remove thread id from the map.
*/
void ThreadHandleMapDelete(ThreadHandleMap *map, DWORD thread_id) {
int i;
for (i = 0; i < map->size; ++i) {
if (map->data[i].id == thread_id) {
FreeEntry(map, i);
return;
}
}
}
/*=========================================================================*/
int SLPDDatabaseDeReg(SLPSrvDeReg* srvdereg)
/* Remove a service registration from the database */
/* */
/* regfile - (IN) filename of the registration file to read into the */
/* database. Pass in NULL for no file. */
/* */
/* Returns - Zero on success. Non-zero if syntax error in registration */
/* file. */
/*=========================================================================*/
{
SLPDDatabaseEntry* del = 0;
SLPDDatabaseEntry* entry = (SLPDDatabaseEntry*)G_DatabaseList.head;
while(entry)
{
if(SLPCompareString(entry->urllen,
entry->url,
srvdereg->urlentry.urllen,
srvdereg->urlentry.url) == 0)
{
if(SLPIntersectStringList(entry->scopelistlen,
entry->scopelist,
srvdereg->scopelistlen,
srvdereg->scopelist) > 0)
{
if(G_SlpdProperty.traceReg)
{
SLPDLogTraceReg("SrvDeReg",entry);
}
del = entry;
break;
}
}
entry = (SLPDDatabaseEntry*) entry->listitem.next;
if(del)
{
FreeEntry((SLPDDatabaseEntry*)SLPListUnlink(&G_DatabaseList,(SLPListItem*)del));
del = 0;
}
}
return 0;
}
struct Task *CreateTask(STRPTR name, LONG pri, APTR initpc, ULONG stacksize)
{ struct Library *SysBase = *(struct Library **)4L;
struct newMemList nml;
struct MemList *ml;
struct Task *newtask;
APTR task2;
stacksize=(stacksize+3)&~3;
{ long *p1,*p2;
int i;
for (p1=(long *)&nml,p2=(long*)&MemTemplate,i=7; i; *p1++=*p2++,i--) ;
*p1=stacksize;
}
if (!(((unsigned int)ml=AllocEntry((struct MemList *)&nml)) & (1<<31))) {
newtask=ml->ml_ME[0].me_Addr;
newtask->tc_Node.ln_Type = NT_TASK;
newtask->tc_Node.ln_Pri = pri;
newtask->tc_Node.ln_Name = name;
newtask->tc_SPReg = (APTR)((ULONG)ml->ml_ME[1].me_Addr+stacksize);
newtask->tc_SPLower = ml->ml_ME[1].me_Addr;
newtask->tc_SPUpper = newtask->tc_SPReg;
NEWLIST(&newtask->tc_MemEntry);
AddHead(&newtask->tc_MemEntry,&ml->ml_Node);
task2=AddTask(newtask,initpc,0);
if (SysBase->lib_Version>36 && !task2) {
FreeEntry(ml); newtask = NULL;
}
}
else
newtask = NULL;
return newtask;
}
/*=========================================================================*/
int SLPDDatabaseReg(SLPSrvReg* srvreg,
int fresh,
pid_t pid,
uid_t uid)
/* Add a service registration to the database */
/* */
/* srvreg - (IN) pointer to the SLPSrvReg to be added to the database */
/* */
/* fresh - (IN) pass in nonzero if the registration is fresh. */
/* */
/* pid - (IN) process id of the process that registered the service */
/* */
/* uid - (IN) user id of the user that registered the service */
/* */
/* Returns - Zero on success. non-zero on error */
/* */
/* NOTE: All registrations are treated as fresh regardless of the */
/* setting of the fresh parameter */
/*=========================================================================*/
{
int result = 0;
SLPDDatabaseEntry* entry = (SLPDDatabaseEntry*)G_DatabaseList.head;
/* Check to see if there is already an identical entry */
while(entry)
{
if(SLPCompareString(entry->urllen,
entry->url,
srvreg->urlentry.urllen,
srvreg->urlentry.url) == 0)
{
if(SLPIntersectStringList(entry->scopelistlen,
entry->scopelist,
srvreg->scopelistlen,
srvreg->scopelist) > 0)
{
SLPListUnlink(&G_DatabaseList,(SLPListItem*)entry);
break;
}
}
entry = (SLPDDatabaseEntry*) entry->listitem.next;
}
/* if no identical entry are found, create a new one */
if(entry == 0)
{
entry = (SLPDDatabaseEntry*)malloc(sizeof(SLPDDatabaseEntry));
if(entry == 0)
{
return -1;
}
memset(entry,0,sizeof(SLPDDatabaseEntry));
}
/* copy info from the message from the wire to the database entry */
entry->pid = pid;
entry->uid = uid;
entry->scopelistlen = srvreg->scopelistlen;
entry->scopelist = (char*)memdup(srvreg->scopelist,srvreg->scopelistlen);
entry->lifetime = srvreg->urlentry.lifetime;
entry->urllen = srvreg->urlentry.urllen;
entry->url = (char*)memdup(srvreg->urlentry.url, srvreg->urlentry.urllen);
entry->srvtypelen = srvreg->srvtypelen;
entry->srvtype = (char*)memdup(srvreg->srvtype,srvreg->srvtypelen);
entry->attrlistlen = srvreg->attrlistlen;
if (entry->attrlistlen)
entry->attrlist = (char*)memdup(srvreg->attrlist,srvreg->attrlistlen);
/* check for malloc() failures */
if(entry->scopelist == 0 ||
entry->url == 0 ||
entry->srvtype == 0 ||
(entry->attrlistlen && entry->attrlist == 0))
{
FreeEntry(entry);
return -1;
}
/* link the new (or modified) entry into the list */
SLPListLinkHead(&G_DatabaseList,(SLPListItem*)entry);
/* traceReg if necessary */
if(G_SlpdProperty.traceReg)
{
SLPDLogTraceReg("SrvReg", entry);
}
return result;
}
/*=========================================================================*/
SLPDDatabaseEntry* SLPDRegFileReadEntry(FILE* fd, SLPDDatabaseEntry** entry)
/* A really big and nasty function that reads an entry SLPDDatabase entry */
/* from a file. Don't look at this too hard or you'll be sick */
/* */
/* fd (IN) file to read from */
/* */
/* entry (OUT) Address of a pointer that will be set to the location of */
/* a dynamically allocated SLPDDatabase entry. The entry */
/* must be freed */
/* */
/* Returns *entry or null on SLPD_ERROR. */
/*=========================================================================*/
{
char* slider1;
char* slider2;
char line[4096];
/* give the out param a value */
*entry = 0;
/*----------------------------------------------------------*/
/* read the next non-white non-comment line from the stream */
/*----------------------------------------------------------*/
do
{
slider1 = RegFileReadLine(fd,line,4096);
if(slider1 == 0)
{
/* read through the whole file and found no entries */
return 0;
}
} while(*slider1 == 0x0d || *slider1 == 0x0a);
/*---------------------------*/
/* Allocate a database entry */
/*---------------------------*/
*entry = SLPDDatabaseEntryAlloc();
if(entry == 0)
{
SLPFatal("Out of memory!\n");
return 0;
}
/*---------------------*/
/* Parse the url-props */
/*---------------------*/
slider2 = strchr(slider1,',');
if(slider2)
{
/* srvurl */
*slider2 = 0; /* squash comma to null terminate srvurl */
(*entry)->url = strdup(TrimWhitespace(slider1));
if((*entry)->url == 0)
{
SLPLog("Out of memory reading srvurl from regfile line ->%s",line);
goto SLPD_ERROR;
}
(*entry)->urllen = strlen((*entry)->url);
/* derive srvtype from srvurl */
(*entry)->srvtype = strstr(slider1,"://");
if((*entry)->srvtype == 0)
{
SLPLog("Looks like a bad url on regfile line ->%s",line);
goto SLPD_ERROR;
}
*(*entry)->srvtype = 0;
(*entry)->srvtype=strdup(TrimWhitespace(slider1));
(*entry)->srvtypelen = strlen((*entry)->srvtype);
slider1 = slider2 + 1;
/*lang*/
slider2 = strchr(slider1,',');
if(slider2)
{
*slider2 = 0; /* squash comma to null terminate lang */
(*entry)->langtag = strdup(TrimWhitespace(slider1));
if((*entry)->langtag == 0)
{
SLPLog("Out of memory reading langtag from regfile line ->%s",line);
goto SLPD_ERROR;
} (*entry)->langtaglen = strlen((*entry)->langtag);
slider1 = slider2 + 1;
}
else
{
SLPLog("Expected language tag near regfile line ->%s\n",line);
goto SLPD_ERROR;
}
/* ltime */
slider2 = strchr(slider1,',');
if(slider2)
{
*slider2 = 0; /* squash comma to null terminate ltime */
(*entry)->lifetime = atoi(slider1);
slider1 = slider2 + 1;
}
else
{
(*entry)->lifetime = atoi(slider1);
slider1 = slider2;
}
if((*entry)->lifetime < 1 || (*entry)->lifetime > 0xffff)
{
SLPLog("Invalid lifetime near regfile line ->%s\n",line);
goto SLPD_ERROR;
}
/* get the srvtype if one was not derived by the srvurl*/
if((*entry)->srvtype == 0)
{
(*entry)->srvtype = strdup(TrimWhitespace(slider1));
if((*entry)->srvtype == 0)
{
SLPLog("Out of memory reading srvtype from regfile line ->%s",line);
goto SLPD_ERROR;
}
(*entry)->srvtypelen = strlen((*entry)->srvtype);
if((*entry)->srvtypelen == 0)
{
SLPLog("Expected to derive service-type near regfile line -> %s\n",line);
goto SLPD_ERROR;
}
}
}
else
{
SLPLog("Expected to find srv-url near regfile line -> %s\n",line);
goto SLPD_ERROR;
}
/*-------------------------------------------------*/
/* Read all the attributes including the scopelist */
/*-------------------------------------------------*/
*line=0;
while(1)
{
if(RegFileReadLine(fd,line,4096) == 0)
{
break;
}
if(*line == 0x0d || *line == 0x0a)
{
break;
}
/* Check to see if it is the scopes line */
/* FIXME We can collapse the scope stuff into the value getting and
* just make it a special case (do strcmp on the tag as opposed to the
* line) of attribute getting.
*/
if(strncasecmp(line,"scopes",6) == 0)
{
/* found scopes line */
slider1 = line;
slider2 = strchr(slider1,'=');
if(slider2)
{
slider2++;
if(*slider2)
{
/* just in case some idiot puts multiple scopes lines */
if((*entry)->scopelist)
{
SLPLog("scopes already defined previous to regfile line ->%s",line);
goto SLPD_ERROR;
}
(*entry)->scopelist=strdup(TrimWhitespace(slider2));
if((*entry)->scopelist == 0)
{
SLPLog("Out of memory adding scopes from regfile line ->%s",line);
goto SLPD_ERROR;
}
(*entry)->scopelistlen = strlen((*entry)->scopelist);
}
}
}
else
{
char *tag; /* Will point to the start of the tag. */
char *val; /* Will point to the start of the value. */
char *end;
char *tag_end;
tag = line;
/*** Elide ws. ***/
while (isspace(*tag))
{
tag++;
}
tag_end = tag;
/*** Find tag end. ***/
while (*tag_end && (!isspace(*tag_end)) && (*tag_end != '=')) {
tag_end++;
}
while (*tag_end && *tag_end != '=') {
tag_end++;
}
*tag_end = 0;
/*** Find value start. ***/
val = tag_end + 1;
/*** Elide ws. ***/
while (isspace(*val))
{
val++;
}
/*** Elide trailing ws. ***/
end = val;
/** Find tag end. **/
while (*end != 0) {
end++;
}
/*** Back up over trailing whitespace. ***/
end--;
while(isspace(*end)) {
*end = 0; /* Overwrite ws. */
end--;
}
SLPAttrSet_guess((*entry)->attr, tag, val, SLP_ADD);
}
}
/* Set the scope to default if not is set */
if((*entry)->scopelist == 0)
{
(*entry)->scopelist=strdup("DEFAULT");
if((*entry)->scopelist == 0)
{
SLPLog("Out of memory adding DEFAULT scope\n");
goto SLPD_ERROR;
}
(*entry)->scopelistlen = 7;
}
return *entry;
SLPD_ERROR:
if(*entry)
{
// if((*entry)->srvtype) free((*entry)->srvtype);
// if((*entry)->url) free((*entry)->url);
// if((*entry)->langtag) free((*entry)->langtag);
// if((*entry)->scopelist) free((*entry)->scopelist);
// if((*entry)->attrlist) free((*entry)->attrlist);
// free(*entry);
FreeEntry(*entry);
*entry = 0;
}
return 0;
}
