/*-------------------------------------------------------------------------*/
int v1ProcessSrvTypeRqst(struct sockaddr_in* peeraddr,
SLPMessage message,
SLPBuffer* sendbuf,
int errorcode)
/*-------------------------------------------------------------------------*/
{
char* type;
char* end;
char* slider;
int i;
int typelen;
int numsrvtypes = 0;
int size = 0;
SLPDDatabaseSrvTypeRqstResult* db = 0;
SLPBuffer result = *sendbuf;
/*-------------------------------------------------*/
/* Check for one of our IP addresses in the prlist */
/*-------------------------------------------------*/
if (SLPIntersectStringList(message->body.srvtyperqst.prlistlen,
message->body.srvtyperqst.prlist,
G_SlpdProperty.interfacesLen,
G_SlpdProperty.interfaces))
{
result->end = result->start;
goto FINISHED;
}
/*------------------------------------*/
/* Make sure that we handle the scope */
/*------------------------------------*/
if (SLPIntersectStringList(message->body.srvtyperqst.scopelistlen,
message->body.srvtyperqst.scopelist,
G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes) != 0)
{
/*------------------------------------*/
/* Find service types in the database */
/*------------------------------------*/
errorcode = SLPDDatabaseSrvTypeRqstStart(message, &db);
}
else
{
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
}
/*----------------------------------------------------------------*/
/* Do not send error codes or empty replies to multicast requests */
/*----------------------------------------------------------------*/
if (message->header.flags & SLP_FLAG_MCAST)
{
if (errorcode != 0 || db->srvtypelistlen == 0)
{
result->end = result->start;
goto FINISHED;
}
}
/*-----------------------------------------------------------------*/
/* ensure the buffer is big enough to handle the whole srvtyperply */
/*-----------------------------------------------------------------*/
size = 16; /* 12 bytes for header, 2 bytes for error code, 2 bytes
for num of service types */
if (errorcode == 0)
{
if (db->srvtypelistlen)
{
/* there has to be at least one service type*/
numsrvtypes = 1;
/* count the rest of the service types */
type = db->srvtypelist;
for (i=0; i< db->srvtypelistlen; i++)
{
if (type[i] == ',')
{
numsrvtypes += 1;
}
}
/* figure out how much memory is required for srvtype strings */
typelen = INT_MAX;
errorcode = SLPv1ToEncoding(0,
&typelen,
message->header.encoding,
db->srvtypelist,
db->srvtypelistlen);
/* TRICKY: we add in the numofsrvtypes + 1 to make room for the */
/* type length. We can do this because the ',' of the comma */
/* delimited list is one byte. */
size = size + typelen + numsrvtypes + 1;
}
else
{
numsrvtypes = 0;
}
}
/*-----------------*/
/* Allocate memory */
/*-----------------*/
result = SLPBufferRealloc(result,size);
if (result == 0)
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
goto FINISHED;
}
/*----------------*/
/* Add the header */
/*----------------*/
/*version*/
*(result->start) = 1;
/*function id*/
*(result->start + 1) = SLP_FUNCT_SRVTYPERPLY;
/*length*/
ToUINT16(result->start + 2, size);
/*flags - TODO set the flags correctly */
*(result->start + 4) = message->header.flags |
(size > SLP_MAX_DATAGRAM_SIZE ? SLPv1_FLAG_OVERFLOW : 0);
/*dialect*/
*(result->start + 5) = 0;
/*language code*/
memcpy(result->start + 6, message->header.langtag, 2);
ToUINT16(result->start + 8, message->header.encoding);
/*xid*/
ToUINT16(result->start + 10, message->header.xid);
/*-----------------------------*/
/* Add rest of the SrvTypeRply */
/*-----------------------------*/
result->curpos = result->start + 12;
/* error code*/
ToUINT16(result->curpos, errorcode);
result->curpos += 2;
if (errorcode == 0)
{
/* num of service types */
ToUINT16(result->curpos, numsrvtypes);
result->curpos += 2;
/* service type strings */
type = db->srvtypelist;
slider = db->srvtypelist;
end = &(type[db->srvtypelistlen]);
for (i=0;i<numsrvtypes; i++)
{
while (slider < end && *slider != ',') slider++;
typelen = size;
/* put in the encoded service type */
SLPv1ToEncoding(result->curpos + 2,
&typelen,
message->header.encoding,
type,
slider - type);
/* slip in the typelen */
ToUINT16(result->curpos, typelen);
result->curpos += 2;
result->curpos += typelen;
slider ++; /* skip comma */
type = slider;
}
/* TODO - make sure we don't return generic types */
}
FINISHED:
if (db) SLPDDatabaseSrvTypeRqstEnd(db);
*sendbuf = result;
return errorcode;
}
/*-------------------------------------------------------------------------*/
int v1ProcessSrvRqst(struct sockaddr_in* peeraddr,
SLPMessage message,
SLPBuffer* sendbuf,
int errorcode)
/*-------------------------------------------------------------------------*/
{
int i;
int urllen;
int size = 0;
SLPDDatabaseSrvRqstResult* db = 0;
SLPBuffer result = *sendbuf;
/*--------------------------------------------------------------*/
/* If errorcode is set, we can not be sure that message is good */
/* Go directly to send response code */
/*--------------------------------------------------------------*/
if (errorcode)
{
goto RESPOND;
}
/*-------------------------------------------------*/
/* Check for one of our IP addresses in the prlist */
/*-------------------------------------------------*/
if (SLPIntersectStringList(message->body.srvrqst.prlistlen,
message->body.srvrqst.prlist,
G_SlpdProperty.interfacesLen,
G_SlpdProperty.interfaces))
{
result->end = result->start;
goto FINISHED;
}
/*------------------------------------------------*/
/* Check to to see if a this is a special SrvRqst */
/*------------------------------------------------*/
if (SLPCompareString(message->body.srvrqst.srvtypelen,
message->body.srvrqst.srvtype,
15,
"directory-agent") == 0)
{
errorcode = v1ProcessDASrvRqst(peeraddr, message, sendbuf, errorcode);
return errorcode;
}
/*------------------------------------*/
/* Make sure that we handle the scope */
/*------ -----------------------------*/
if (SLPIntersectStringList(message->body.srvrqst.scopelistlen,
message->body.srvrqst.scopelist,
G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes) != 0)
{
/*-------------------------------*/
/* Find services in the database */
/*-------------------------------*/
errorcode = SLPDDatabaseSrvRqstStart(message, &db);
}
else
{
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
}
RESPOND:
/*----------------------------------------------------------------*/
/* Do not send error codes or empty replies to multicast requests */
/*----------------------------------------------------------------*/
if (message->header.flags & SLP_FLAG_MCAST)
{
if (errorcode != 0 || db->urlcount == 0)
{
result->end = result->start;
goto FINISHED;
}
}
/*-------------------------------------------------------------*/
/* ensure the buffer is big enough to handle the whole srvrply */
/*-------------------------------------------------------------*/
size = 16; /* 12 bytes for header, 2 bytes for error code, 2 bytes
for url count */
if (errorcode == 0)
{
for (i = 0; i < db->urlcount; i++)
{
urllen = INT_MAX;
errorcode = SLPv1ToEncoding(0,
&urllen,
message->header.encoding,
db->urlarray[i]->url,
db->urlarray[i]->urllen);
if (errorcode)
break;
size += urllen + 4; /* 2 bytes for lifetime, 2 bytes for urllen */
}
result = SLPBufferRealloc(result,size);
if (result == 0)
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
}
}
/*----------------*/
/* Add the header */
/*----------------*/
/*version*/
*(result->start) = 1;
/*function id*/
*(result->start + 1) = SLP_FUNCT_SRVRPLY;
/*length*/
ToUINT16(result->start + 2, size);
/*flags - TODO set the flags correctly */
*(result->start + 4) = message->header.flags |
(size > SLP_MAX_DATAGRAM_SIZE ? SLPv1_FLAG_OVERFLOW : 0);
/*dialect*/
*(result->start + 5) = 0;
/*language code*/
memcpy(result->start + 6, message->header.langtag, 2);
ToUINT16(result->start + 8, message->header.encoding);
/*xid*/
ToUINT16(result->start + 10, message->header.xid);
/*-------------------------*/
/* Add rest of the SrvRply */
/*-------------------------*/
result->curpos = result->start + 12;
/* error code*/
ToUINT16(result->curpos, errorcode);
result->curpos = result->curpos + 2;
if (errorcode == 0)
{
/* urlentry count */
ToUINT16(result->curpos, db->urlcount);
result->curpos = result->curpos + 2;
for (i = 0; i < db->urlcount; i++)
{
/* url-entry lifetime */
ToUINT16(result->curpos, db->urlarray[i]->lifetime);
result->curpos = result->curpos + 2;
/* url-entry url and urllen */
urllen = size;
errorcode = SLPv1ToEncoding(result->curpos + 2,
&urllen,
message->header.encoding,
db->urlarray[i]->url,
db->urlarray[i]->urllen);
ToUINT16(result->curpos, urllen);
result->curpos = result->curpos + 2 + urllen;
}
}
else
{
/* urlentry count */
ToUINT16(result->curpos, 0);
result->curpos = result->curpos + 2;
}
FINISHED:
SLPDDatabaseSrvRqstEnd(db);
*sendbuf = result;
return errorcode;
}
/*-------------------------------------------------------------------------*/
int v1ProcessAttrRqst(struct sockaddr_in* peeraddr,
SLPMessage message,
SLPBuffer* sendbuf,
int errorcode)
/*-------------------------------------------------------------------------*/
{
SLPDDatabaseAttrRqstResult* db = 0;
int attrlen = 0;
int size = 0;
SLPBuffer result = *sendbuf;
/*--------------------------------------------------------------*/
/* If errorcode is set, we can not be sure that message is good */
/* Go directly to send response code */
/*--------------------------------------------------------------*/
if (errorcode)
{
goto RESPOND;
}
/*-------------------------------------------------*/
/* Check for one of our IP addresses in the prlist */
/*-------------------------------------------------*/
if (SLPIntersectStringList(message->body.attrrqst.prlistlen,
message->body.attrrqst.prlist,
G_SlpdProperty.interfacesLen,
G_SlpdProperty.interfaces))
{
result->end = result->start;
goto FINISHED;
}
/*------------------------------------*/
/* Make sure that we handle the scope */
/*------ -----------------------------*/
if (SLPIntersectStringList(message->body.attrrqst.scopelistlen,
message->body.attrrqst.scopelist,
G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes))
{
/*---------------------------------*/
/* Find attributes in the database */
/*---------------------------------*/
errorcode = SLPDDatabaseAttrRqstStart(message,&db);
}
else
{
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
}
RESPOND:
/*----------------------------------------------------------------*/
/* Do not send error codes or empty replies to multicast requests */
/*----------------------------------------------------------------*/
if (message->header.flags & SLP_FLAG_MCAST)
{
if (errorcode != 0 || db->attrlistlen == 0)
{
result->end = result->start;
goto FINISHED;
}
}
/*--------------------------------------------------------------*/
/* ensure the buffer is big enough to handle the whole attrrply */
/*--------------------------------------------------------------*/
size = 16; /* 12 bytes for header, 2 bytes for error code, 2 bytes
for attr-list len */
if (errorcode == 0)
{
attrlen = INT_MAX;
errorcode = SLPv1ToEncoding(0, &attrlen,
message->header.encoding,
db->attrlist,
db->attrlistlen);
size += attrlen;
}
/*-------------------*/
/* Alloc the buffer */
/*-------------------*/
result = SLPBufferRealloc(result,size);
if (result == 0)
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
goto FINISHED;
}
/*----------------*/
/* Add the header */
/*----------------*/
/*version*/
*(result->start) = 1;
/*function id*/
*(result->start + 1) = SLP_FUNCT_ATTRRPLY;
/*length*/
ToUINT16(result->start + 2, size);
/*flags - TODO set the flags correctly */
*(result->start + 4) = message->header.flags |
(size > SLP_MAX_DATAGRAM_SIZE ? SLPv1_FLAG_OVERFLOW : 0);
/*dialect*/
*(result->start + 5) = 0;
/*language code*/
memcpy(result->start + 6, message->header.langtag, 2);
ToUINT16(result->start + 8, message->header.encoding);
/*xid*/
ToUINT16(result->start + 10, message->header.xid);
/*--------------------------*/
/* Add rest of the AttrRply */
/*--------------------------*/
result->curpos = result->start + 12;
/* error code*/
ToUINT16(result->curpos, errorcode);
result->curpos = result->curpos + 2;
if (errorcode == 0)
{
/* attr-list len */
ToUINT16(result->curpos, attrlen);
result->curpos = result->curpos + 2;
attrlen = size;
SLPv1ToEncoding(result->curpos, &attrlen,
message->header.encoding,
db->attrlist,
db->attrlistlen);
result->curpos = result->curpos + attrlen;
}
FINISHED:
*sendbuf = result;
if (db) SLPDDatabaseAttrRqstEnd(db);
return errorcode;
}
/*-------------------------------------------------------------------------*/
int v1ProcessSrvTypeRqst(struct sockaddr_in* peeraddr,
SLPMessage message,
SLPBuffer* sendbuf,
int errorcode)
/*-------------------------------------------------------------------------*/
{
int i, typelen;
int size = 0;
int count = 0;
int found = 0;
SLPDDatabaseSrvType* srvtypearray = 0;
SLPBuffer result = *sendbuf;
/*-------------------------------------------------*/
/* Check for one of our IP addresses in the prlist */
/*-------------------------------------------------*/
if(SLPIntersectStringList(message->body.srvtyperqst.prlistlen,
message->body.srvtyperqst.prlist,
G_SlpdProperty.interfacesLen,
G_SlpdProperty.interfaces))
{
result->end = result->start;
goto FINISHED;
}
/*------------------------------------*/
/* Make sure that we handle the scope */
/*------------------------------------*/
if(SLPIntersectStringList(message->body.srvtyperqst.scopelistlen,
message->body.srvtyperqst.scopelist,
G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes) != 0)
{
/*------------------------------------*/
/* Find service types in the database */
/*------------------------------------*/
while(found == count)
{
count += G_SlpdProperty.maxResults;
if(srvtypearray) free(srvtypearray);
srvtypearray = (SLPDDatabaseSrvType*)malloc(sizeof(SLPDDatabaseSrvType) * count);
if(srvtypearray == 0)
{
found = 0;
errorcode = SLP_ERROR_INTERNAL_ERROR;
break;
}
found = SLPDDatabaseFindType(&(message->body.srvtyperqst), srvtypearray, count);
if(found < 0)
{
found = 0;
errorcode = SLP_ERROR_INTERNAL_ERROR;
break;
}
}
/* remember the amount found if is really big for next time */
if(found > G_SlpdProperty.maxResults)
{
G_SlpdProperty.maxResults = found;
}
}
else
{
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
}
/*----------------------------------------------------------------*/
/* Do not send error codes or empty replies to multicast requests */
/*----------------------------------------------------------------*/
if(message->header.flags & SLP_FLAG_MCAST)
{
if(found == 0 || errorcode != 0)
{
result->end = result->start;
goto FINISHED;
}
}
/*-----------------------------------------------------------------*/
/* ensure the buffer is big enough to handle the whole srvtyperply */
/*-----------------------------------------------------------------*/
size = 16; /* 12 bytes for header, 2 bytes for error code, 2 bytes
for srvtype count */
if(errorcode == 0)
{
for(i=0;i<found;i++)
{
typelen = INT_MAX;
errorcode = SLPv1ToEncoding(0, &typelen,
message->header.encoding,
srvtypearray[i].type,
srvtypearray[i].typelen);
if(errorcode)
break;
size += typelen + 2; /* 2 byte for length */
}
}
result = SLPBufferRealloc(result,size);
if(result == 0)
{
found = 0;
errorcode = SLP_ERROR_INTERNAL_ERROR;
}
/*----------------*/
/* Add the header */
/*----------------*/
/*version*/
*(result->start) = 1;
/*function id*/
*(result->start + 1) = SLP_FUNCT_SRVTYPERPLY;
/*length*/
ToUINT16(result->start + 2, size);
/*flags - TODO set the flags correctly */
*(result->start + 4) = message->header.flags |
(size > SLP_MAX_DATAGRAM_SIZE ? SLPv1_FLAG_OVERFLOW : 0);
/*dialect*/
*(result->start + 5) = 0;
/*language code*/
memcpy(result->start + 6, message->header.langtag, 2);
ToUINT16(result->start + 8, message->header.encoding);
/*xid*/
ToUINT16(result->start + 10, message->header.xid);
/*-----------------------------*/
/* Add rest of the SrvTypeRply */
/*-----------------------------*/
result->curpos = result->start + 12;
/* error code*/
ToUINT16(result->curpos, errorcode);
result->curpos += 2;
/* service type count */
ToUINT16(result->curpos, found);
result->curpos += 2;
/* TODO - make sure we don't return generic types */
for(i=0;i<found;i++)
{
typelen = size;
SLPv1ToEncoding(result->curpos + 2, &typelen,
message->header.encoding,
srvtypearray[i].type,
srvtypearray[i].typelen);
ToUINT16(result->curpos, srvtypearray[i].typelen);
result->curpos += 2 + typelen;
}
FINISHED:
if(srvtypearray) free(srvtypearray);
*sendbuf = result;
return errorcode;
}
