/*=========================================================================*/
int SLPDDatabaseReInit(const char* regfile)
/* Re-initialize the database with changed registrations from a regfile. */
/* */
/* regfile (IN) the regfile to register. */
/* */
/* Returns - zero on success or non-zero on error. */
/*=========================================================================*/
{
SLPDatabaseHandle dh;
SLPDatabaseEntry* entry;
SLPMessage msg;
SLPBuffer buf;
FILE* fd;
/*------------------------------------------------------------------*/
/* open the database handle and remove all the static registrations */
/* (the registrations from the /etc/slp.reg) file. */
/*------------------------------------------------------------------*/
dh = SLPDatabaseOpen(&G_SlpdDatabase.database);
if ( dh )
{
while ( 1 )
{
entry = SLPDatabaseEnum(dh);
if ( entry == NULL ) break;
if ( entry->msg->body.srvreg.source == SLP_REG_SOURCE_STATIC )
{
SLPDatabaseRemove(dh,entry);
}
}
SLPDatabaseClose(dh);
}
/*--------------------------------------*/
/* Read static registration file if any */
/*--------------------------------------*/
if ( regfile )
{
fd = fopen(regfile,"rb");
if ( fd )
{
while ( SLPDRegFileReadSrvReg(fd, &msg, &buf) == 0 )
{
SLPDDatabaseReg(msg, buf);
}
fclose(fd);
}
}
return 0;
}
/*-------------------------------------------------------------------------*/
void ProcessSrvReg(SLPDPeerInfo* peerinfo,
SLPMessage message,
SLPBuffer result)
/*-------------------------------------------------------------------------*/
{
int errorcode;
if(message->header.flags & SLP_FLAG_MCAST)
{
/* don't do anything multicast SrvReg (set result empty) */
result->end = result->start;
return;
}
/*------------------------------------*/
/* Make sure that we handle the scope */
/*------ -----------------------------*/
if(SLPStringListIntersect(message->body.srvreg.scopelistlen,
message->body.srvreg.scopelist,
G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes))
{
/*-------------------------------*/
/* TODO: Validate the authblocks */
/*-------------------------------*/
/*---------------------------------*/
/* put the service in the database */
/*---------------------------------*/
if(SLPDDatabaseReg(&(message->body.srvreg),
message->header.flags | SLP_FLAG_FRESH,
getpid(),
getuid()) == 0)
{
errorcode = 0;
}
else
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
}
}
else
{
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
}
/*------------------------------------------------------------*/
/* ensure the buffer is big enough to handle the whole srvack */
/*------------------------------------------------------------*/
result = SLPBufferRealloc(result,message->header.langtaglen + 16);
/*----------------*/
/* Add the header */
/*----------------*/
/*version*/
*(result->start) = 2;
/*function id*/
*(result->start + 1) = SLP_FUNCT_SRVACK;
/*length*/
ToUINT24(result->start + 2,message->header.langtaglen + 16);
/*flags*/
ToUINT16(result->start + 5,0);
/*ext offset*/
ToUINT24(result->start + 7,0);
/*xid*/
ToUINT16(result->start + 10,message->header.xid);
/*lang tag len*/
ToUINT16(result->start + 12,message->header.langtaglen);
/*lang tag*/
memcpy(result->start + 14,
message->header.langtag,
message->header.langtaglen);
/*-------------------*/
/* Add the errorcode */
/*-------------------*/
ToUINT16(result->start + 14 + message->header.langtaglen, errorcode);
}
/** Process a general service registration message.
*
* @param[in] message - The message to process.
* @param[in] recvbuf - The buffer associated with @p message.
* @param[out] sendbuf - The response buffer to fill.
* @param[in] errorcode - The error code from the client request.
*
* @return A non-zero value if @p message should be silently dropped.
*
* @internal
*/
static int ProcessSrvReg(SLPMessage * message, SLPBuffer recvbuf,
SLPBuffer * sendbuf, int errorcode)
{
SLPBuffer result = *sendbuf;
/* If errorcode is set, we can not be sure that message is good
Go directly to send response code also do not process mcast
srvreg or srvdereg messages
*/
if (errorcode || message->header.flags & SLP_FLAG_MCAST
|| SLPNetIsMCast(&(message->peer)))
goto RESPOND;
/* make sure that we handle the scope */
if (SLPIntersectStringList(message->body.srvreg.scopelistlen,
message->body.srvreg.scopelist, G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes))
{
#ifdef ENABLE_SLPv2_SECURITY
/* Validate the authblocks */
errorcode = SLPAuthVerifyUrl(G_SlpdSpiHandle, 0,
&message->body.srvreg.urlentry);
if (errorcode == 0)
{
errorcode = SLPAuthVerifyString(G_SlpdSpiHandle, 0,
message->body.srvreg.attrlistlen,
message->body.srvreg.attrlist,
message->body.srvreg.authcount,
message->body.srvreg.autharray);
}
if (errorcode == 0)
#endif
{
/* Put the registration in the database. */
/* TRICKY: Remember the recvbuf was duplicated back in
* SLPDProcessMessage
*/
if (SLPNetIsLoopback(&(message->peer)))
message->body.srvreg.source= SLP_REG_SOURCE_LOCAL;
else
message->body.srvreg.source = SLP_REG_SOURCE_REMOTE;
errorcode = SLPDDatabaseReg(message, recvbuf);
}
}
else
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
RESPOND:
/* don't send back reply anything multicast SrvReg (set result empty) */
if (message->header.flags & SLP_FLAG_MCAST
|| SLPNetIsMCast(&(message->peer)))
{
result->end = result->start;
goto FINISHED;
}
/* ensure the buffer is big enough to handle the whole srvack */
result = SLPBufferRealloc(result, message->header.langtaglen + 16);
if (result == 0)
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
goto FINISHED;
}
/* Add the header */
/* version */
*result->curpos++ = 2;
/* function id */
*result->curpos++ = SLP_FUNCT_SRVACK;
/* length */
PutUINT24(&result->curpos, message->header.langtaglen + 16);
/* flags */
PutUINT16(&result->curpos, 0);
/* ext offset */
PutUINT24(&result->curpos, 0);
/* xid */
PutUINT16(&result->curpos, message->header.xid);
/* lang tag len */
PutUINT16(&result->curpos, message->header.langtaglen);
/* lang tag */
memcpy(result->curpos, message->header.langtag,
message->header.langtaglen);
result->curpos += message->header.langtaglen;
/* Add the errorcode */
PutUINT16(&result->curpos, errorcode);
FINISHED:
*sendbuf = result;
return errorcode;
}
/*-------------------------------------------------------------------------*/
int ProcessSrvReg(struct sockaddr_in* peeraddr,
SLPMessage message,
SLPBuffer* sendbuf,
int errorcode)
/* */
/* Returns: non-zero if message should be silently dropped */
/*-------------------------------------------------------------------------*/
{
unsigned int regtype;
SLPBuffer result = *sendbuf;
/*--------------------------------------------------------------*/
/* If errorcode is set, we can not be sure that message is good */
/* Go directly to send response code also do not process mcast */
/* srvreg or srvdereg messages */
/*--------------------------------------------------------------*/
if(errorcode || message->header.flags & SLP_FLAG_MCAST)
{
goto RESPOND;
}
/*------------------------------------*/
/* Make sure that we handle the scope */
/*------ -----------------------------*/
if(SLPIntersectStringList(message->body.srvreg.scopelistlen,
message->body.srvreg.scopelist,
G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes))
{
/*-------------------------------*/
/* TODO: Validate the authblocks */
/*-------------------------------*/
/*---------------------------------*/
/* put the service in the database */
/*---------------------------------*/
regtype = 0;
if(message->header.flags & SLP_FLAG_FRESH)
{
regtype |= SLPDDATABASE_REG_FRESH;
}
if(ISLOCAL(peeraddr->sin_addr))
{
regtype |= SLPDDATABASE_REG_LOCAL;
}
errorcode = SLPDDatabaseReg(&(message->body.srvreg),regtype);
if(errorcode > 0)
{
errorcode = SLP_ERROR_INVALID_REGISTRATION;
}
else if(errorcode < 0)
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
}
}
else
{
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
}
RESPOND:
/*--------------------------------------------------------------------*/
/* don't send back reply anything multicast SrvReg (set result empty) */
/*--------------------------------------------------------------------*/
if(message->header.flags & SLP_FLAG_MCAST ||
ISMCAST(peeraddr->sin_addr))
{
result->end = result->start;
goto FINISHED;
}
/*------------------------------------------------------------*/
/* ensure the buffer is big enough to handle the whole srvack */
/*------------------------------------------------------------*/
result = SLPBufferRealloc(result,message->header.langtaglen + 16);
if(result == 0)
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
goto FINISHED;
}
/*----------------*/
/* Add the header */
/*----------------*/
/*version*/
*(result->start) = 2;
/*function id*/
*(result->start + 1) = SLP_FUNCT_SRVACK;
/*length*/
ToUINT24(result->start + 2,message->header.langtaglen + 16);
/*flags*/
ToUINT16(result->start + 5,0);
/*ext offset*/
ToUINT24(result->start + 7,0);
/*xid*/
ToUINT16(result->start + 10,message->header.xid);
/*lang tag len*/
ToUINT16(result->start + 12,message->header.langtaglen);
/*lang tag*/
memcpy(result->start + 14,
message->header.langtag,
message->header.langtaglen);
/*-------------------*/
/* Add the errorcode */
/*-------------------*/
ToUINT16(result->start + 14 + message->header.langtaglen, errorcode);
FINISHED:
*sendbuf = result;
return errorcode;
}
/*-------------------------------------------------------------------------*/
int v1ProcessSrvReg(struct sockaddr_in* peeraddr,
SLPMessage message,
SLPBuffer recvbuf,
SLPBuffer* sendbuf,
int errorcode)
/* */
/* Returns: non-zero if message should be silently dropped */
/*-------------------------------------------------------------------------*/
{
SLPBuffer result = *sendbuf;
/*--------------------------------------------------------------*/
/* If errorcode is set, we can not be sure that message is good */
/* Go directly to send response code also do not process mcast */
/* srvreg or srvdereg messages */
/*--------------------------------------------------------------*/
if (errorcode || message->header.flags & SLP_FLAG_MCAST)
{
goto RESPOND;
}
/*------------------------------------*/
/* Make sure that we handle the scope */
/*------ -----------------------------*/
if (SLPIntersectStringList(message->body.srvreg.scopelistlen,
message->body.srvreg.scopelist,
G_SlpdProperty.useScopesLen,
G_SlpdProperty.useScopes))
{
/*---------------------------------*/
/* put the service in the database */
/*---------------------------------*/
if (ISLOCAL(message->peer.sin_addr))
{
message->body.srvreg.source= SLP_REG_SOURCE_LOCAL;
}
else
{
message->body.srvreg.source = SLP_REG_SOURCE_REMOTE;
}
errorcode = SLPDDatabaseReg(message,recvbuf);
}
else
{
errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
}
RESPOND:
/*--------------------------------------------------------------------*/
/* don't send back reply anything multicast SrvReg (set result empty) */
/*--------------------------------------------------------------------*/
if (message->header.flags & SLP_FLAG_MCAST)
{
result->end = result->start;
goto FINISHED;
}
/*------------------------------------------------------------*/
/* ensure the buffer is big enough to handle the whole srvack */
/*------------------------------------------------------------*/
result = SLPBufferRealloc(result, 14);
if (result == 0)
{
errorcode = SLP_ERROR_INTERNAL_ERROR;
goto FINISHED;
}
/*----------------*/
/* Add the header */
/*----------------*/
/*version*/
*(result->start) = 1;
/*function id*/
*(result->start + 1) = SLP_FUNCT_SRVACK;
/*length*/
ToUINT16(result->start + 2, 14);
/*flags - TODO set the flags correctly */
*(result->start + 4) = 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 the errorcode */
/*-------------------*/
ToUINT16(result->start + 12, errorcode);
FINISHED:
*sendbuf = result;
return errorcode;
}
