/*-------------------------------------------------------------------------*/
SLPError ProcessSrvReg(PSLPHandleInfo handle)
/*-------------------------------------------------------------------------*/
{
int sock;
struct sockaddr_in peeraddr;
int bufsize = 0;
char* buf = 0;
char* curpos = 0;
SLPError result = 0;
#ifdef ENABLE_SECURITY
int urlauthlen = 0;
unsigned char* urlauth = 0;
int attrauthlen = 0;
unsigned char* attrauth = 0;
if(SLPPropertyAsBoolean(SLPGetProperty("net.slp.securityEnabled")))
{
result = SLPAuthSignUrl(handle->hspi,
0,
0,
handle->params.reg.urllen,
handle->params.reg.url,
&urlauthlen,
&urlauth);
if(result == 0)
{
result = SLPAuthSignString(handle->hspi,
0,
0,
handle->params.reg.attrlistlen,
handle->params.reg.attrlist,
&attrauthlen,
&attrauth);
}
bufsize += urlauthlen;
bufsize += attrauthlen;
}
#endif
/*-------------------------------------------------------------------*/
/* determine the size of the fixed portion of the SRVREG */
/*-------------------------------------------------------------------*/
bufsize += handle->params.reg.urllen + 6; /* 1 byte for reserved */
/* 2 bytes for lifetime */
/* 2 bytes for urllen */
/* 1 byte for authcount */
bufsize += handle->params.reg.srvtypelen + 2; /* 2 bytes for len field */
bufsize += handle->params.reg.scopelistlen + 2; /* 2 bytes for len field */
bufsize += handle->params.reg.attrlistlen + 2; /* 2 bytes for len field */
bufsize += 1; /* 1 byte for authcount */
buf = curpos = (char*)xmalloc(bufsize);
if(buf == 0)
{
result = SLP_MEMORY_ALLOC_FAILED;
goto FINISHED;
}
/*------------------------------------------------------------*/
/* Build a buffer containing the fixed portion of the SRVREG */
/*------------------------------------------------------------*/
/* url-entry reserved */
*curpos= 0;
curpos = curpos + 1;
/* url-entry lifetime */
ToUINT16(curpos,handle->params.reg.lifetime);
curpos = curpos + 2;
/* url-entry urllen */
ToUINT16(curpos,handle->params.reg.urllen);
curpos = curpos + 2;
/* url-entry url */
memcpy(curpos,
handle->params.reg.url,
handle->params.reg.urllen);
curpos = curpos + handle->params.reg.urllen;
/* url-entry authblock */
#ifdef ENABLE_SECURITY
if(urlauth)
{
/* authcount */
*curpos = 1;
curpos = curpos + 1;
/* authblock */
memcpy(curpos,urlauth,urlauthlen);
curpos = curpos + urlauthlen;
}
else
#endif
{
/* authcount */
*curpos = 0;
curpos = curpos + 1;
}
/* service type */
ToUINT16(curpos,handle->params.reg.srvtypelen);
curpos = curpos + 2;
memcpy(curpos,
handle->params.reg.srvtype,
handle->params.reg.srvtypelen);
curpos = curpos + handle->params.reg.srvtypelen;
/* scope list */
ToUINT16(curpos,handle->params.reg.scopelistlen);
curpos = curpos + 2;
memcpy(curpos,
handle->params.reg.scopelist,
handle->params.reg.scopelistlen);
curpos = curpos + handle->params.reg.scopelistlen;
/* attr list */
ToUINT16(curpos,handle->params.reg.attrlistlen);
curpos = curpos + 2;
memcpy(curpos,
handle->params.reg.attrlist,
handle->params.reg.attrlistlen);
curpos = curpos + handle->params.reg.attrlistlen;
/* attribute auth block */
#ifdef ENABLE_SECURITY
if(attrauth)
{
/* authcount */
*curpos = 1;
curpos = curpos + 1;
/* authblock */
memcpy(curpos,attrauth,attrauthlen);
curpos = curpos + attrauthlen;
}
else
#endif
{
/* authcount */
*curpos = 0;
curpos = curpos + 1;
}
/*--------------------------*/
/* Call the RqstRply engine */
/*--------------------------*/
do
{
sock = NetworkConnectToSA(handle,
handle->params.reg.scopelist,
handle->params.reg.scopelistlen,
&peeraddr);
if(sock == -1)
{
result = SLP_NETWORK_INIT_FAILED;
break;
}
result = NetworkRqstRply(sock,
&peeraddr,
handle->langtag,
buf,
SLP_FUNCT_SRVREG,
bufsize,
CallbackSrvReg,
handle);
if(result)
{
NetworkDisconnectSA(handle);
}
}while(result == SLP_NETWORK_ERROR);
FINISHED:
if(buf) xfree(buf);
#ifdef ENABLE_SECURITY
if(urlauth) xfree(urlauth);
if(attrauth) xfree(attrauth);
#endif
return result;
}
/*-------------------------------------------------------------------------*/
SLPError ProcessSrvDeReg(PSLPHandleInfo handle)
/*-------------------------------------------------------------------------*/
{
int sock;
struct sockaddr_in peeraddr;
int bufsize = 0;
char* buf = 0;
char* curpos = 0;
SLPError result = 0;
/*-------------------------------------------------------------------*/
/* determine the size of the fixed portion of the SRVREG */
/*-------------------------------------------------------------------*/
bufsize += handle->params.dereg.scopelistlen + 2; /* 2 bytes for len field*/
bufsize += handle->params.dereg.urllen + 8; /* 1 byte for reserved */
/* 2 bytes for lifetime */
/* 2 bytes for urllen */
/* 1 byte for authcount */
bufsize += 2; /* 2 bytes for taglistlen*/
/* TODO: Fix this for authentication */
buf = curpos = (char*)malloc(bufsize);
if(buf == 0)
{
result = SLP_MEMORY_ALLOC_FAILED;
goto FINISHED;
}
/*------------------------------------------------------------*/
/* Build a buffer containing the fixed portion of the SRVDEREG*/
/*------------------------------------------------------------*/
/* scope list */
ToUINT16(curpos,handle->params.dereg.scopelistlen);
curpos = curpos + 2;
memcpy(curpos,
handle->params.dereg.scopelist,
handle->params.dereg.scopelistlen);
curpos = curpos + handle->params.dereg.scopelistlen;
/* url-entry reserved */
*curpos = 0;
curpos = curpos + 1;
/* url-entry lifetime */
ToUINT16(curpos, 0);
curpos = curpos + 2;
/* url-entry urllen */
ToUINT16(curpos,handle->params.dereg.urllen);
curpos = curpos + 2;
/* url-entry url */
memcpy(curpos,
handle->params.dereg.url,
handle->params.dereg.urllen);
curpos = curpos + handle->params.dereg.urllen;
/* url-entry authcount */
*curpos = 0;
curpos = curpos + 1;
/* TODO: put in urlentry authentication stuff */
/* tag list */
/* TODO: put in taglist stuff */
ToUINT16(curpos,0);
/*--------------------------*/
/* Call the RqstRply engine */
/*--------------------------*/
do
{
sock = NetworkConnectToSA(handle,
handle->params.dereg.scopelist,
handle->params.dereg.scopelistlen,
&peeraddr);
if(sock == -1)
{
result = SLP_NETWORK_INIT_FAILED;
break;
}
result = NetworkRqstRply(sock,
&peeraddr,
handle->langtag,
buf,
SLP_FUNCT_SRVDEREG,
bufsize,
CallbackSrvDeReg,
handle);
if(result)
{
NetworkDisconnectSA(handle);
}
}while(result == SLP_NETWORK_ERROR);
FINISHED:
if(buf) free(buf);
return result;
}
/** Formats and sends an SLPReg wire buffer request.
*
* @param handle - The OpenSLP session handle, containing request
* parameters. See docs for SLPReg.
*
* @return Zero on success, or an SLP API error code.
*
* @internal
*/
static SLPError ProcessSrvReg(SLPHandleInfo * handle)
{
sockfd_t sock;
uint8_t * buf;
uint8_t * curpos;
SLPError serr;
size_t extoffset = 0;
int urlauthlen = 0;
uint8_t * urlauth = 0;
int attrauthlen = 0;
uint8_t * attrauth = 0;
SLPBoolean watchRegPID;
struct sockaddr_storage saaddr;
#ifdef ENABLE_SLPv2_SECURITY
if (SLPPropertyAsBoolean("net.slp.securityEnabled"))
{
int err = SLPAuthSignUrl(handle->hspi, 0, 0, handle->params.reg.urllen,
handle->params.reg.url, &urlauthlen, &urlauth);
if (err == 0)
err = SLPAuthSignString(handle->hspi, 0, 0,
handle->params.reg.attrlistlen, handle->params.reg.attrlist,
&attrauthlen, &attrauth);
if (err != 0)
return SLP_AUTHENTICATION_ABSENT;
}
#endif
/* Should we send the "Watch Registration PID" extension? */
watchRegPID = SLPPropertyAsBoolean("net.slp.watchRegistrationPID");
/* 0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| <URL-Entry> \
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| length of service type string | <service-type> \
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| length of <scope-list> | <scope-list> \
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| length of attr-list string | <attr-list> \
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|# of AttrAuths |(if present) Attribute Authentication Blocks...\
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| WATCH-PID extension ID | next extension offset \
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| nxo (cont) | process identifier to be monitored \
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| PID (cont) |
+-+-+-+-+-+-+-+-+ */
buf = curpos = xmalloc(
+ SizeofURLEntry(handle->params.reg.urllen, urlauthlen)
+ 2 + handle->params.reg.srvtypelen
+ 2 + handle->params.reg.scopelistlen
+ 2 + handle->params.reg.attrlistlen
+ 1 + attrauthlen
+ (watchRegPID? (2 + 3 + 4): 0));
if (buf == 0)
{
xfree(urlauth);
xfree(attrauth);
return SLP_MEMORY_ALLOC_FAILED;
}
/* URL entry */
PutURLEntry(&curpos, handle->params.reg.lifetime, handle->params.reg.url,
handle->params.reg.urllen, urlauth, urlauthlen);
/* <service-type> */
PutL16String(&curpos, handle->params.reg.srvtype,
handle->params.reg.srvtypelen);
/* <scope-list> */
PutL16String(&curpos, handle->params.reg.scopelist,
handle->params.reg.scopelistlen);
/* <attr-list> */
PutL16String(&curpos, handle->params.reg.attrlist,
handle->params.reg.attrlistlen);
/** @todo Handle multiple attribute authentication blocks. */
/* Attribute Authentication Blocks */
*curpos++ = attrauth? 1: 0;
memcpy(curpos, attrauth, attrauthlen);
curpos += attrauthlen;
/* SLP_EXTENSION_ID_REG_PID */
if (watchRegPID)
{
extoffset = curpos - buf;
/** @todo In some future code base, this should be changed to use the
* non-deprecated official version, SLP_EXTENSION_ID_REG_PID. For now
* we need to use the EXPerimental version in order to interoperate
* properly with OpenSLP 1.x SA's.
*/
PutUINT16(&curpos, SLP_EXTENSION_ID_REG_PID_EXP);
PutUINT24(&curpos, 0);
PutUINT32(&curpos, SLPPidGet());
}
/* Call the Request-Reply engine. */
sock = NetworkConnectToSA(handle, handle->params.reg.scopelist,
handle->params.reg.scopelistlen, &saaddr);
if (sock != SLP_INVALID_SOCKET)
{
serr = NetworkRqstRply(sock, &saaddr, handle->langtag, extoffset,
buf, SLP_FUNCT_SRVREG, curpos - buf, CallbackSrvReg, handle);
if (serr)
NetworkDisconnectSA(handle);
}
else
serr = SLP_NETWORK_INIT_FAILED;
xfree(buf);
xfree(urlauth);
xfree(attrauth);
return serr;
}
/*-------------------------------------------------------------------------*/
SLPError ProcessSrvDeReg(PSLPHandleInfo handle)
/*-------------------------------------------------------------------------*/
{
int sock;
struct sockaddr_storage peeraddr;
int bufsize = 0;
char* buf = 0;
char* curpos = 0;
SLPError result = 0;
#ifdef ENABLE_SLPv2_SECURITY
int urlauthlen = 0;
unsigned char* urlauth = 0;
if(SLPPropertyAsBoolean(SLPGetProperty("net.slp.securityEnabled")))
{
result = SLPAuthSignUrl(handle->hspi,
0,
0,
handle->params.dereg.urllen,
handle->params.dereg.url,
&urlauthlen,
&urlauth);
bufsize += urlauthlen;
}
#endif
/*-------------------------------------------------------------------*/
/* determine the size of the fixed portion of the SRVDEREG */
/*-------------------------------------------------------------------*/
bufsize += handle->params.dereg.scopelistlen + 2; /* 2 bytes for len field*/
bufsize += handle->params.dereg.urllen + 6; /* 1 byte for reserved */
/* 2 bytes for lifetime */
/* 2 bytes for urllen */
/* 1 byte for authcount */
bufsize += 2; /* 2 bytes for taglistlen*/
/*--------------------------------------------*/
/* Allocate a buffer for the SRVDEREG message */
/*--------------------------------------------*/
buf = curpos = (char*)xmalloc(bufsize);
if(buf == 0)
{
result = SLP_MEMORY_ALLOC_FAILED;
goto FINISHED;
}
/*------------------------------------------------------------*/
/* Build a buffer containing the fixed portion of the SRVDEREG*/
/*------------------------------------------------------------*/
/* scope list */
ToUINT16(curpos,handle->params.dereg.scopelistlen);
curpos = curpos + 2;
memcpy(curpos,
handle->params.dereg.scopelist,
handle->params.dereg.scopelistlen);
curpos = curpos + handle->params.dereg.scopelistlen;
/* url-entry reserved */
*curpos = 0;
curpos = curpos + 1;
/* url-entry lifetime */
ToUINT16(curpos, 0);
curpos = curpos + 2;
/* url-entry urllen */
ToUINT16(curpos,handle->params.dereg.urllen);
curpos = curpos + 2;
/* url-entry url */
memcpy(curpos,
handle->params.dereg.url,
handle->params.dereg.urllen);
curpos = curpos + handle->params.dereg.urllen;
/* url-entry authcount */
#ifdef ENABLE_SLPv2_SECURITY
if(urlauth)
{
/* authcount */
*(curpos) = 1;
curpos = curpos + 1;
/* authblock */
memcpy(curpos,urlauth,urlauthlen);
curpos = curpos + urlauthlen;
}
else
#endif
{
/* authcount */
*(curpos) = 0;
curpos = curpos + 1;
}
/* tag list */
/* TODO: No tag list for now put in taglist stuff */
ToUINT16(curpos,0);
/*--------------------------*/
/* Call the RqstRply engine */
/*--------------------------*/
sock = NetworkConnectToSA(handle,
handle->params.reg.scopelist,
handle->params.reg.scopelistlen,
&peeraddr);
if(sock >= 0)
{
result = NetworkRqstRply(sock,
&peeraddr,
handle->langtag,
0,
buf,
SLP_FUNCT_SRVDEREG,
bufsize,
CallbackSrvDeReg,
handle);
if (result)
{
NetworkDisconnectSA(handle);
}
}
else
{
result = SLP_NETWORK_INIT_FAILED;
goto FINISHED;
}
FINISHED:
if(buf) xfree(buf);
#ifdef ENABLE_SLPv2_SECURITY
if(urlauth) xfree(urlauth);
#endif
return result;
}
