/*----------------------------------------------------------------------*
rtp_threads_init
*----------------------------------------------------------------------*/
int rtp_threads_init (void)
{
NATIVE_PROFILE_PAL_NETWORK();
int i;
#if (INCLUDE_RUN_TIME_CONFIG)
IPTaskContinuation = (HAL_CONTINUATION *) rtp_malloc(sizeof(HAL_CONTINUATION) * CFG_NIFACES);
InterruptTaskContinuation = (HAL_CONTINUATION *) rtp_malloc(sizeof(HAL_CONTINUATION) * CFG_NIFACES);
IPTaskInitialized = (int *) rtp_malloc(sizeof(int) * CFG_NIFACES);
InterruptTaskContInitialized = (int *) rtp_malloc(sizeof(int) * CFG_NIFACES);
if ( ((int)IPTaskContinuation== -1) || ((int)InterruptTaskContinuation== -1) ||
((int)IPTaskInitialized== -1) || ((int)InterruptTaskContInitialized== -1) )
{
return (-1);
}
if ( ((int)IPTaskContinuation== NULL) || ((int)InterruptTaskContinuation== NULL) ||
((int)IPTaskInitialized== NULL) || ((int)InterruptTaskContInitialized== NULL) )
{
return (-1);
}
#endif
for (i = 0; i < CFG_NIFACES; i++)
{
IPTaskInitialized[i] = 0;
InterruptTaskContInitialized[i] = 0;
}
TimerTaskContInitialized = 0;
TimerTaskCompInitialized = 0;
DHCPTaskInitialized = 0;
return (0);
}
int _UPnP_DeviceSendServiceAlive(
UPnPService *service /** pointer to the service */)
{
char notifySubType[11]; /* holds ssdp:alive */
char destAddr[RTP_NET_NI_MAXHOST];
char *usn;
UPnPRootDevice *rootDevice = service->device->rootDevice;
char *descLocation;
int result = -1;
int ipType = service->device->rootDevice->deviceRuntime->upnpRuntime->ssdpContext.ipType;
/* proceed if complete device information is available */
if(!service->serviceId || !service->serviceType || !service->device->rootDevice->descLocation)
{
return (-1);
}
if (ipType == RTP_NET_TYPE_IPV4)
{
rtp_strcpy(destAddr, (const char *) v4mcastAddr);
}
else if (ipType == RTP_NET_TYPE_IPV6)
{
rtp_strcpy(destAddr, IPV6_LINK_LOCAL_ADDRESS);
}
descLocation = _getLocation((unsigned char *) destAddr, mcastPort, ipType, rootDevice);
if (descLocation)
{
/* allocate memory to notifytype to hold UDN, devicetype, :: and a string terminator */
usn = (char *) rtp_malloc((rtp_strlen(service->serviceId) + rtp_strlen(service->serviceType) + 3));
if (usn)
{
/* create a notify type using device UDN and device type */
rtp_strcpy(usn, service->serviceId);
rtp_strcat(usn, "::");
rtp_strcat(usn, service->serviceType);
rtp_strcpy(notifySubType, "ssdp:alive");
/* service advertisement */
if(SSDP_SendAlive (&rootDevice->deviceRuntime->upnpRuntime->ssdpContext,
service->serviceType,
usn,
descLocation,
(SSDP_UINT32*)&rootDevice->deviceRuntime->remoteCacheTimeoutSec) >= 0)
{
result = 0;
}
rtp_free(usn);
}
_freeLocation(rootDevice, descLocation);
}
return (result);
}
/*----------------------------------------------------------------------*
rtp_file_gfirst
*----------------------------------------------------------------------*/
int rtp_file_gfirst (void ** dirobj, char * name)
{
VDSTAT* nativeDirObj;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
nativeDirObj = (VDSTAT*) rtp_malloc(sizeof(VDSTAT));
rtp_memset(nativeDirObj, 0, sizeof(VDSTAT));
if (!vf_gfirst(nativeDirObj, (PFCHAR) name))
{
rtp_free(nativeDirObj);
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_gfirst: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*dirobj = (void*) nativeDirObj;
return (0);
}
/** @memo Create a list or menu object.
@doc Creates a list or menu object and returns a handle that may be passed
to other functions that add to, access and execute user dialogs.
storage location.
@precondition None
@return A non null void * handle on success. 0 otherwise.
*/
void *rtp_gui_list_init(
void *pguictx, /** Hook for GUI context (parent window handle). Zero for generic implementation. */
int style, /** <br>
RTP_LIST_STYLE_MENU - Format as a menu.<br>
RTP_LIST_STYLE_HELP - Format as a help message<br>
RTP_LIST_STYLE_LISTBOX - Format as a list box.<br>
RTP_LIST_STYLE_NOFORMAT - Do not format greyed expandable etc.<br>
*/
char *title, /** Title to display */
char *subtitle, /** Sub-title to display */
char *prompt /** Prompt to use when requesting input */
)
{
struct rtp_gui_list *plist;
plist = (struct rtp_gui_list *) rtp_malloc(sizeof(*plist));
if (plist)
{
rtp_memset(plist, 0, sizeof(*plist));
plist->pguictx = pguictx;
plist->style = style;
plist->title = title;
plist->subtitle = subtitle;
plist->prompt = prompt;
}
return(void *) plist;
}
/*---------------------------------------------------------------------------*/
HTTPAuthenticationRealm * _HTTP_NewRealm (
const HTTP_CHAR* realmName,
const HTTP_CHAR* path,
HTTP_INT32 ttlSec,
HTTPAuthenticationScheme scheme
)
{
HTTPAuthenticationRealm * realm = (HTTPAuthenticationRealm *) rtp_malloc(sizeof(HTTPAuthenticationRealm));
if (realm)
{
tc_memset(realm, 0, sizeof(HTTPAuthenticationRealm));
if (realmName)
{
tc_strncpy(realm->realmName, realmName, HTTP_CFG_MAX_REALMNAME_LEN-1);
realm->realmName[HTTP_CFG_MAX_REALMNAME_LEN-1] = 0;
}
if (path)
{
tc_strncpy(realm->path, path, HTTP_CFG_MAX_PATH_LEN-1);
realm->path[HTTP_CFG_MAX_PATH_LEN-1] = 0;
}
else
{
realm->path[0] = 0;
}
realm->scheme = scheme;
}
return (realm);
}
static HTTP_CHAR *http_demo_alloc_string(HTTP_CHAR *string)
{
HTTP_CHAR *r;
r = rtp_malloc(rtp_strlen(string)+1);
if (r)
rtp_strcpy(r, string);
return(r);
}
/*---------------------------------------------------------------------------*/
char * _rtp_strdup (const char *str)
{
long len = (rtp_strlen(str) + 1) * sizeof(char);
char *s = (char *) rtp_malloc(len);
if (s)
{
rtp_memcpy(s, str, len);
}
return (s);
}
SOAP_INT32 SOAP_SendActionRequest (
SOAPAction* action
)
{
SOAP_CHAR* requestBuffer;
SOAP_INT32 contentLen;
HTTPRequest request;
/* Create soap envelope for the request */
requestBuffer = (char *)rtp_malloc(action->bodyLen +
SOAP_ACTION_ENVELOPE_LENGTH);
if (requestBuffer)
{
rtp_sprintf(requestBuffer, SOAP_ACTION_REQUEST_TEMPLATE,
action->bodyStr);
/* get the length of the envelope which is the content length of SOAP Request */
contentLen = rtp_strlen(requestBuffer);
/* send a Post or a M-Post request */
switch(action->state)
{
case SOAP_ACTION_CONNECTING_POST:
/* Create soap envelope for the request */
#if (USE_EXPERIMENTAL_REQUEST)
HTTP_ManagedClientRequestExExperimental(action->httpSession, "POST", action->postTargetURL.field.http.path, NULL,
"text/xml; charset=\"utf-8\"", &contentLen, &request, "SOAPAction", action->soapAction);
#else
HTTP_ManagedClientRequestEx (action->httpSession, "POST", action->postTargetURL.field.http.path, NULL,
"text/xml; charset=\"utf-8\"", contentLen, &request);
#endif
break;
case SOAP_ACTION_CONNECTING_M_POST:
HTTP_ManagedClientRequestEx (action->httpSession, "M-POST", action->postTargetURL.field.http.path, NULL,
"text/xml; charset=\"utf-8\"", contentLen, &request);
HTTP_SetRequestHeaderStr (&request, "Man", "\"http://schemas.xmlsoap.org/soap/envelope/\"; ns=s");
HTTP_SetRequestHeaderStr (&request, "s-SOAPAction", action->soapAction);
break;
}
HTTP_ManagedClientRequestHeaderDone (action->httpSession, &request);
/* write the POST data */
HTTP_ManagedClientWrite (action->httpSession, (SOAP_UINT8*)requestBuffer, contentLen);
/* signal that the request is compete */
HTTP_ManagedClientWriteDone (action->httpSession);
rtp_free(requestBuffer);
return(0);
}
return (-1);
}
static void * safemalloc(rtsmb_size bytes)
{
void * Result = rtp_malloc(bytes);
if (bytes && !Result)
{
rtp_printf(("SMB Server: out of heap space\n"));
exit(1);
}
tc_memset(Result, 0, bytes);
return Result;
}
/** @memo Add an text entry and a void * value a list or menu object.
@doc Adds text and to a list or object. Also provides a void * value to attach to the item that will be returned
when the item is selected. <br>
If rtp_gui_list_execute() is called itemvalue will be returned. <br>
If rtp_gui_list_execute_handle() is called the handle to the item is returned.
@precondition rtp_gui_list_init must be called first.
@return A handle to the menu or list entry object.
*/
void *rtp_gui_list_add_item(void *vplist, /** Handle returned from rtp_gui_list_init(). */
char *item, /** Text to display for the choice. */
void *itemvalue, /** void *value to return when the item is selected. */
int indentlevel, /** Spaces to indent when text is displayed. */
int isgreyed, /** 1 if the item may not be selected. */
int style /** Additional style attributes. <br>
RTP_LIST_ITEM_STYLE_NOBREAK - Display this and the next list item side by side. <br>
RTP_LIST_ITEM_STYLE_SUBMENU - Itemvalue is a menu or list handle returned from rtp_gui_list_init(). <br>
RTP_LIST_ITEM_STYLE_COLLAPSED - Don't display the submenu/sublist.<br>
RTP_LIST_ITEM_STYLE_EXPANDED - Expand and display the submenu/sublist. <br>
*/
)
{
struct rtp_gui_list *plist;
struct rtp_gui_list_item *newitem;
plist = (struct rtp_gui_list *) vplist;
newitem = (struct rtp_gui_list_item *) rtp_malloc(sizeof(*newitem));
if (!newitem)
return(0);
rtp_memset(newitem, 0, sizeof(*newitem));
newitem->item = rtp_strdup(item);
if (!newitem->item)
{
rtp_free(newitem);
return(0);
}
newitem->itemid = itemvalue;
newitem->indentlevel = indentlevel;
newitem->isgreyed = isgreyed;
newitem->style = style;
{
struct rtp_gui_list_item *pthis;
pthis = plist->itemlist;
if (!pthis)
plist->itemlist = newitem;
else
{
while (pthis->pnext)
{
pthis = pthis->pnext;
}
pthis->pnext = newitem;
}
}
plist->itemlistcount += 1;
return((void *) newitem);
}
/** @memo Opens a file using the supplied name.
@doc Opens a file using the mode settings, and sets the
file information.
@return 0 if successful, -1 on failure, and -2 if a non-fatal
error occurred.
*/
int rtp_stdio_fopen (
void ** rtpfile, /** A pointer to the address of an RTP_FILE to store the file information. */
const char * fname, /** The name of the file to open. */
const char * mode /** For the mode argument:<br>
<pre>
| "r" Open a file for reading only RTP_FILE_O_RDONLY
| "r+" Open a file for reading and writing RTP_FILE_O_RDWR
| "w" Open a file for writing only RTP_FILE_O_WRONLY
| Create a file if it does not exist RTP_FILE_O_CREAT
| Truncate a file to 0 bytes after opening RTP_FILE_O_TRUNC
| "w+" Open a file for reading and writing RTP_FILE_O_RDWR
| Create a file if it does not exist RTP_FILE_O_CREAT
| Truncate a file to 0 bytes after opening RTP_FILE_O_TRUNC
| "a" All writes will be appended to the file RTP_FILE_O_APPEND
| Create a file if it does not exist RTP_FILE_O_CREAT
| "a+" Open a file for reading and writing RTP_FILE_O_RDWR
| All writes will be appended to the file RTP_FILE_O_APPEND
| Create a file if it does not exist RTP_FILE_O_CREAT
| "b..." b prepended to the mode in the open call
| causes the file to be opened in binary mode RTP_FILE_O_BINARY
| "t..." t prepended to the mode in the open call
| causes the file to be opened in text mode RTP_FILE_O_TEXT
| Note: If neither the b or t are prepended, text
| mode is the default implementation.
</pre> */
)
{
RTP_STDIO_FILE * p;
int result;
result = (-1);
p = (RTP_STDIO_FILE *) rtp_malloc ((unsigned int) sizeof (*p), 0); /* SPRZ */
if (p)
{
rtp_memset(p, 0, sizeof(*p));
p->verify = RTP_FILE_VERIFICATION_VALUE;
if ((result = rtp_file_open (&(p->handle), fname, _rtp_mode_to_permission(mode), RTP_FILE_S_IWRITE | RTP_FILE_S_IREAD)) != 0)
{
/* --------------------------------------- */
/* ERROR: drop the handle block. */
/* --------------------------------------- */
rtp_free ((void *)p);
}
}
*rtpfile = (void *)p;
return (result);
}
SSDP_INT32 SSDP_SendResponse (
SSDPServerContext *ctx, /** pointer to SSDP context */
SSDPPendingResponse *response /** buffer holding response information */)
{
SSDP_CHAR *msgBuffer;
SSDP_SOCKET responseSock = ctx->announceSocket;
msgBuffer = (SSDP_CHAR *) rtp_malloc(sizeof(SSDP_CHAR) * SSDP_BUFFER_SIZE);
if (msgBuffer)
{
/* Send response */
rtp_sprintf(msgBuffer,"HTTP/1.1 200 OK\r\n"
"LOCATION: %s\r\n"
"EXT: \r\n"
"USN: %s\r\n"
"SERVER: %s\r\n"
"CACHE-CONTROL: max-age=%d\r\n"
"ST: %s\r\n"
"\r\n",
response->targetLocation,
response->targetUSN,
ctx->serverName,
response->targetTimeoutSec,
response->searchTarget);
RTP_LOG_WRITE("SSDPSendResponse SEND", msgBuffer, rtp_strlen(msgBuffer))
/* Send response to the requesting client */
if (rtp_net_sendto(responseSock, (unsigned char*)msgBuffer,
rtp_strlen(msgBuffer),
response->clientAddr.ipAddr,
response->clientAddr.port,
response->clientAddr.type) < 0)
{
SSDP_ProcessError("Response");
rtp_free(msgBuffer);
return(-1);
}
/* Free up the allocated memory */
rtp_free(msgBuffer);
}
else
{
return (-1);
/*---------------------------------------------------------------------------*/
HTTPAuthenticationHost * _HTTP_NewHost (
const HTTP_CHAR* hostName,
HTTP_UINT16 port
)
{
HTTPAuthenticationHost * host = (HTTPAuthenticationHost *) rtp_malloc(sizeof(HTTPAuthenticationHost));
if (host)
{
tc_memset(host, 0, sizeof(HTTPAuthenticationHost));
tc_strncpy(host->hostName, hostName, HTTP_CFG_MAX_HOSTNAME_LEN-1);
host->hostName[HTTP_CFG_MAX_HOSTNAME_LEN-1] = 0;
host->port = port;
DLLIST_INIT(&host->realmList);
}
return (host);
}
/*----------------------------------------------------------------------*
rtp_sig_semaphore_alloc
*----------------------------------------------------------------------*/
int rtp_sig_semaphore_alloc (RTP_SEMAPHORE *newSem, const char *name)
{
P_POLLOS_SIGNAL poll_sig;
poll_sig = (P_POLLOS_SIGNAL)rtp_malloc(sizeof(struct pollos_signal), 0); /* SPRZ */
if (poll_sig)
{
poll_sig->signal_count = 0;
poll_sig->signal_timeout = 0;
*newSem = (RTP_HANDLE)poll_sig;
/* success, return */
return(0);
}
RTP_DEBUG_OUTPUT_STR("rtp_sig_semaphore_alloc: Semaphore not Created!");
return (-1);
}
static int _LoadPalleteFromPalletTemplate(HBROWSER_HANDLE hbrowser, HDOC_HANDLE hdoc, int isShadow)
{
char newhtml[256];
IXML_Element *ParentElement;
IXML_Element *xmlElement;
IXML_Document *Doc = PalletTemplate;
char *lbuffer,*p;
HELEMENT_HANDLE h;
p = (char *) rtp_malloc(100000);
lbuffer = p;
*p = 0;
newhtml[0] = 0;
if (isShadow)
h = webc_DocFindElement (hdoc, "ShadowPallete", 0, HTML_ELEMENT_ANY, 0);
else
h = webc_DocFindElement (hdoc, "Pallete", 0, HTML_ELEMENT_ANY, 0);
if (!h)
goto error;
xmlElement = 0;
ParentElement = rtpxmlGetElemInDocFromDomStr(Doc, PALLETDOMSTR); /* "PalletImages" */
if (ParentElement)
xmlElement = (IXML_Element *)ixmlNode_getFirstChild((IXML_Node*) ParentElement);
while (xmlElement)
{
if (xmlPalletElementToHtml(xmlElement, newhtml, isShadow) != 0)
goto error;
rtp_strcat(p,newhtml); p += rtp_strlen(p);
xmlElement = (IXML_Element *) ixmlNode_getNextSibling((IXML_Node*) xmlElement);
}
webc_ElementSetInnerHtmlASCII (h, lbuffer);
if (lbuffer)
rtp_free(lbuffer);
return 0;
error:
if (lbuffer)
rtp_free(lbuffer);
printf("Error CreatePalleteFromPalletTemplate()\n");
assert(0);
return -1;
}
static int http_server_demo_restart(void)
{
HTTP_INT16 ipType = 4;
/* Initialize the server */
ExampleServerCtx.connectCtxArray = (HTTPServerConnection*) rtp_malloc(sizeof(HTTPServerConnection) * ExampleServerCtx.numConnections);
if (!ExampleServerCtx.connectCtxArray)
return -1;
if (HTTP_ServerInit (
&ExampleServerCtx.httpServer,
DEMO_SERVER_NAME, // name
ExampleServerCtx.rootDirectory, // rootDir
ExampleServerCtx.defaultFile, // defaultFile
1, // httpMajorVersion
1, // httpMinorVersion
0, // ExampleServerCtx.defaultIpAddr, // Use the default IP address
80, // 80 ?? Use the www default port
DEMO_IPVERSION, // ipversion type(4 or 6)
0, // allowKeepAlive
ExampleServerCtx.connectCtxArray, // connectCtxArray
ExampleServerCtx.numConnections, // maxConnections
ExampleServerCtx.numHelperThreads // maxHelperThreads
) < 0)
return -1;
/* Demonstrate using the server API by setting up virtual pages, and assigning callback handlers */
/* Set up tables of virtual content that we will server from source code */
http_demo_init_vcontent();
/* Create "demo_form.html" uses a ram based web page and demonstrates froms processing */
if (http_server_create_virtual_form(&ExampleServerCtx.httpServer) != 0)
{
return(-1);
}
/* Create a virtual default web page that we'll use as a sign on instructional page. */
if (http_server_create_virtual_index(&ExampleServerCtx.httpServer) != 0)
{
return(-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_sig_semaphore_alloc
*----------------------------------------------------------------------*/
int rtp_sig_semaphore_alloc (RTP_SEMAPHORE *newSem, const char *name)
{
NATIVE_PROFILE_PAL_NETWORK();
P_POLLOS_SIGNAL poll_sig;
poll_sig = (P_POLLOS_SIGNAL)rtp_malloc((unsigned long )sizeof(struct pollos_signal));
if (poll_sig)
{
poll_sig->signal_count = 0;
poll_sig->signal_timeout = 0;
*newSem = (RTP_HANDLE)poll_sig;
/* success, return */
return(0);
}
RTP_DEBUG_OUTPUT_STR("rtp_sig_semaphore_alloc: Semaphore not Created!");
return (-1);
}
/* Start or restart the server. Called when the application is first run and when callback handlers
request a restart of the server because parametrs have been changed */
static int http_server_demo_restart(void)
{
HTTP_INT16 ipType = DEMO_IPVERSION; /* The API supports V6 but the demo is wired for V4 right now */
HTTP_UINT8 *pDefaultIpAddr;
/* The demo uses 0,0,0,0 to signify use default but the API uses a null pointer so
map the demo methodology to the API metodology */
if (ExampleServerCtx.defaultIpAddr[0] == 0 &&
ExampleServerCtx.defaultIpAddr[1] == 0 &&
ExampleServerCtx.defaultIpAddr[2] == 0 &&
ExampleServerCtx.defaultIpAddr[3] == 0)
pDefaultIpAddr = 0;
else
pDefaultIpAddr = &ExampleServerCtx.defaultIpAddr[0];
rtp_printf("Starting or restarting server \n");
/* Allocate and clear one server context per possible simultaneous connection. see (DEMO_MAX_CONNECTIONS) */
if (!ExampleServerCtx.connectCtxArray)
{
ExampleServerCtx.connectCtxArray = (HTTPServerConnection*) rtp_malloc(sizeof(HTTPServerConnection) * ExampleServerCtx.numConnections);
if (!ExampleServerCtx.connectCtxArray)
return -1;
}
rtp_memset(ExampleServerCtx.connectCtxArray,0, sizeof(HTTPServerConnection) * ExampleServerCtx.numConnections);
/* Initialize the server */
if (HTTP_ServerInit (
&ExampleServerCtx.httpServer,
DEMO_SERVER_NAME, // name
ExampleServerCtx.rootDirectory, // rootDir
ExampleServerCtx.defaultFile, // defaultFile
1, // httpMajorVersion
1, // httpMinorVersion
pDefaultIpAddr,
80, // 80 ?? Use the www default port
DEMO_IPVERSION, // ipversion type(4 or 6)
0, // allowKeepAlive
ExampleServerCtx.connectCtxArray, // connectCtxArray
ExampleServerCtx.numConnections, // maxConnections
ExampleServerCtx.numHelperThreads // maxHelperThreads
) < 0)
return -1;
/* Set up request handlers for requests for typical index urls request index.html, index.htm and none */
/* This api assigns _Demo_UrlRequestHandler() as a callback handler ti url "\\index.html" */
if (HTTP_ServerAddPath(&ExampleServerCtx.httpServer,
"\\index.html", 1,(HTTPRequestHandler)_Demo_UrlRequestHandler,
(HTTPServerPathDestructor)_Demo_UrlRequestDestructor, (void *) 0) < 0)
return (-1);
/* Assign_Demo_UrlRequestHandler() as a callback handler ti url "\\index.htm" */
if (HTTP_ServerAddPath(&ExampleServerCtx.httpServer,
"\\index.htm", 1,(HTTPRequestHandler)_Demo_UrlRequestHandler,
(HTTPServerPathDestructor)_Demo_UrlRequestDestructor, (void *) 0) < 0)
return (-1);
/* Add "\\" */
if (HTTP_ServerAddPath(&ExampleServerCtx.httpServer,
"\\", 1,(HTTPRequestHandler)_Demo_UrlRequestHandler,
(HTTPServerPathDestructor)_Demo_UrlRequestDestructor, (void *) 0) < 0)
return (-1);
/* Add a callback for the dismiss url. This is a one liner so piggyback it on our default handler */
if (HTTP_ServerAddPath(&ExampleServerCtx.httpServer,
"\\dismiss.htm", 1,(HTTPRequestHandler)_Demo_UrlRequestHandler,
(HTTPServerPathDestructor)_Demo_UrlRequestDestructor, (void *) DEMO_DISMISS_ID) < 0)
return (-1);
/* Call external function to initialize advanced examples */
if (http_demo_init_vcontent(&ExampleServerCtx.httpServer) != 0)
return(-1);
return (0);
}
static HTMLEventStatus FlyingWindowBodyCallback(wcCtx* Ctx, wcEL element,HTMLEvent* event, char* param)
{ /* Close the Browser window when the dismiss button is clicked. */
int CycleTimer = 0;
int MaxX,MaxY;
struct flyingwindowcontrol *pcontrol;
MaxX = 600; // Should call get canvas
MaxY = 600;
if (event->type == HTML_EVENT_OBJECT_CREATED)
{
struct flyingwindowcontrol *pcontrol;
pcontrol = (struct flyingwindowcontrol *)rtp_malloc(sizeof(struct flyingwindowcontrol));
pcontrol->iteration = 0;
pcontrol->xstep = 4;
pcontrol->ystep = 2;
wcPushData(Ctx, element, (void*) pcontrol);
CycleTimer = 1;
}
else if (event->type == HTML_EVENT_MOUSEDOWN)
{ // experimental
pcontrol = (struct flyingwindowcontrol *) wcGetData(Ctx, element);
wcPopData(Ctx, element);
rtp_free(pcontrol);
wcWinClose(Ctx);
StartFlyingWindowDemo(0, 10, WF_SPRITE);
return (HTML_EVENT_STATUS_HALT);
}
else if (event->type == HTML_EVENT_TIMER)
{
int left,top,width,height;
pcontrol = (struct flyingwindowcontrol *) wcGetData(Ctx, element);
pcontrol->iteration += 1;
if (pcontrol->iteration >= FLYINGWINDOWITERATIONS)
{
// free private data
wcPopData(Ctx, element);
rtp_free(pcontrol);
// Make a private copy of the stack based context to pass to the Global timer handler
wcCtx* KillCtx;
KillCtx = (wcCtx*)rtp_malloc(sizeof(*Ctx));
*KillCtx = *Ctx;
// Tell the global timer to call our close callback routine
wcTimedCallback(FlyingWindowCloseCallback,0, 0, (void *) KillCtx);
return (HTML_EVENT_STATUS_CONTINUE);
}
wcWinGetPos(Ctx, &left, &top, &width, &height);
left += pcontrol->xstep;
if (left < 0)
{
left = 0;
pcontrol->xstep *= -1;
}
else if (left+width >= MaxX)
{
left -= pcontrol->xstep;
pcontrol->xstep *= -1;
}
top += pcontrol->ystep;
if (top < 0)
{
top = 0;
pcontrol->ystep *= -1;
}
else if (top+height >= MaxY)
{
top -= pcontrol->ystep;
pcontrol->ystep *= -1;
}
wcWinSetPos(Ctx, left, top, width, height);
CycleTimer = 1;
}
if (CycleTimer)
{
HTMLEvent NewEvent;
rtp_memset(&NewEvent, 0 ,sizeof(NewEvent));
NewEvent.type = HTML_EVENT_TIMER;
wcTriggerEvent(element, &NewEvent, FLYINGWINDOWPERIOD);
}
return (HTML_EVENT_STATUS_CONTINUE);
}
/** @memo
@doc
@return error code
*/
SOAPActionState _SOAP_ParseActionRespose (
HTTPResponseInfo* info,
HTTPManagedClientSession* session,
SOAPActionResponse* response
)
{
SOAP_INT32 result;
SOAP_INT32 responseBytesRead = 0;
SOAP_INT32 responseBufferSize = SOAP_RESPONSE_BUFFER_LENGTH;
RTPXML_NodeList* elements;
RTPXML_Element* envelopeElem;
SOAP_CHAR* responseBuffer;
SOAPActionState state = SOAP_ACTION_ERROR;
if(info->status == 200) //OK
{
response->status = SOAP_RESPONSE_NORMAL;
}
else
{
response->status = SOAP_RESPONSE_FAULT;
}
/* collect the response and store it in responseBuffer */
/* Create soap envelope for the request */
responseBuffer = (char *)rtp_malloc(SOAP_RESPONSE_BUFFER_LENGTH);
if (!responseBuffer)
{
return (-1);
}
rtp_memset((SOAP_UINT8*)responseBuffer, 0, SOAP_RESPONSE_BUFFER_LENGTH);
do
{
/* if the buffer is full, then add some space to read data into */
if (responseBytesRead == responseBufferSize)
{
SOAP_CHAR* newBuffer = rtp_realloc(
responseBuffer,
responseBufferSize + SOAP_RESPONSE_BUFFER_LENGTH
);
if (newBuffer)
{
responseBuffer = newBuffer;
responseBufferSize = responseBufferSize + SOAP_RESPONSE_BUFFER_LENGTH;
}
else
{
break;
}
}
result = HTTP_ManagedClientRead (
session,
(SOAP_UINT8*)(responseBuffer + responseBytesRead),
responseBufferSize - responseBytesRead
);
if (result == 0)
{
break;
}
responseBytesRead += result;
}
/* if we filled the buffer, then try to read more data */
while (result > 0);
/* If there is nothing after 500 "Description" then point the fault string at the description */
if (responseBytesRead == 0)
{
response->status = SOAP_REQUEST_ERROR;
response->fault.string = info->httpReply;
response->fault.code = response->fault.string;
return(SOAP_ACTION_RESPONSE_READ);
}
if (result == 0)
{
/* this is OK because we allocated an extra byte above */
responseBuffer[responseBytesRead] = 0;
state = SOAP_ACTION_RESPONSE_READ;
if(rtpxmlParseBufferEx(responseBuffer, &response->envelope.doc) != RTPXML_SUCCESS)
{
processing_error:
response->status = SOAP_REQUEST_ERROR;
response->fault.string = "Soap Action failed but XML error response is badly formed";
response->fault.code = response->fault.string;
rtp_free(responseBuffer);
return(state);
}
elements = rtpxmlDocument_getElementsByTagNameNS (
response->envelope.doc,
"http://schemas.xmlsoap.org/soap/envelope/",
"Envelope");
if (!elements)
{
rtpxmlNodeList_free(elements);
goto processing_error;
}
envelopeElem = (RTPXML_Element *) rtpxmlNodeList_item(elements, 0);
rtpxmlNodeList_free(elements);
if (!envelopeElem)
{
goto processing_error;
}
elements = rtpxmlElement_getElementsByTagNameNS (
envelopeElem,
"http://schemas.xmlsoap.org/soap/envelope/",
"Body");
if (elements)
{
response->envelope.bodyElem = (RTPXML_Element *) rtpxmlNodeList_item(elements, 0);
rtpxmlNodeList_free(elements);
}
else
{
response->envelope.bodyElem = 0;
}
elements = rtpxmlElement_getElementsByTagNameNS (
envelopeElem,
"http://schemas.xmlsoap.org/soap/envelope/",
"Header");
if (elements)
{
response->envelope.headerElem = (RTPXML_Element *) rtpxmlNodeList_item(elements, 0);
rtpxmlNodeList_free(elements);
}
else
{
response->envelope.headerElem = 0;
}
/* If action response is error, store error description */
if(response->status == SOAP_RESPONSE_FAULT)
{
if (response->envelope.bodyElem)
{
response->fault.code = UPnP_DOMGetElemTextInElem(response->envelope.bodyElem, "faultcode", 0);
response->fault.string = UPnP_DOMGetElemTextInElem(response->envelope.bodyElem, "faultstring", 0);
elements = rtpxmlElement_getElementsByTagName (
response->envelope.bodyElem,
"detail");
if (elements)
{
response->fault.detailElem = (RTPXML_Element *) rtpxmlNodeList_item(elements, 0);
rtpxmlNodeList_free(elements);
}
else
{
response->fault.detailElem = 0;
}
}
}
}
rtp_free(responseBuffer);
return(state);
}
/* Start dragging helem. */
int webc_SlidingWindowOpen(
HBROWSER_HANDLE hbrowser,
HDOC_HANDLE hdoc,
int WindowTop,
int WindowLeft,
int WindowHeight,
int WindowWidth,
HELEMENT_HANDLE SlidingElement,
int SlidingElementStartTop,
int SlidingElementStartLeft,
unsigned long Controlflags,
SlidingCallbackFunction cb)
{
struct _webcSlidingWindowView *SlideObject;
HELEMENT_HANDLE SlideWindow;
char style_buff[512];
SlideWindow = webc_GetSlidingWindow(hbrowser, hdoc);
if (!SlideWindow)
goto error;
SlideObject = (struct _webcSlidingWindowView *) rtp_malloc(sizeof(* SlideObject));
if (!SlideObject)
goto error;
rtp_memset(SlideObject,0,sizeof(*SlideObject));
// SlideObject->WindowRect.Set(WindowLeft, WindowTop, WindowLeft+WindowWidth-1, WindowTop+WindowHeight-1);
SlideObject->WindowTop = WindowTop;
SlideObject->WindowLeft = WindowLeft;
SlideObject->WindowHeight = WindowHeight;
SlideObject->WindowWidth = WindowWidth;
SlideObject->Controlflags = Controlflags;
SlideObject->SlidingElement = SlidingElement;
SlideObject->SlidingElementStartTop = SlidingElementStartTop;
SlideObject->SlidingElementStartLeft = SlidingElementStartLeft;
SlideObject->SlidingElementCurrentTop = SlidingElementStartTop;
SlideObject->SlidingElementCurrentLeft = SlidingElementStartLeft;
SlideObject->cb = cb;
/* Install a listener for display events */
webc_ElementEnableDisplayEvents(SlidingElement);
/* Move the start position of the element underneath us and show it */
/* Done below too, may not be needed. */
webc_ElementSetXYPosition(SlidingElement, SlidingElementStartLeft, SlidingElementStartTop);
/* Hide the sliding window */
webc_ElementHide(SlidingElement, WEBC_TRUE);
/* Put it inside the SlideWindow */
if (webc_ElementGetParent(SlidingElement))
webc_ElementRemoveChild(webc_ElementGetParent(SlidingElement),SlidingElement);
webc_ElementInsertFirst(SlideWindow,SlidingElement);
/* Set an event handler */
webc_ElementSetPrivateData(SlidingElement,SlideObject);
webc_ElementSetTagEventHandler(SlidingElement, SlidingWindowEventHandler);
/* Show the viewport with the sliding window inside it, clipped. */
rtp_sprintf(style_buff,"height:%dpx;width:%dpx;\"", WindowHeight, WindowWidth);
webc_ElementSetStyleASCII(SlideWindow, style_buff, WEBC_TRUE);
webc_ElementSetXYPosition(SlideWindow, WindowLeft, WindowTop);
webc_ElementHide(SlideWindow, WEBC_FALSE);
/* Move the start position of the element underneath us and show it */
webc_ElementSetXYPosition(SlidingElement, SlidingElementStartLeft, SlidingElementStartTop);
webc_ElementHide(SlidingElement, WEBC_FALSE);
return 0;
error:
assert(0);
return -1;
}
/** SOAP callback for UPnP. Handles a single incoming SOAP control request by
parsing the action document and calling the device callback.
@return error code; tells SOAP whether the action was successful or
generated a fault
*/
int UPnP_DeviceControlSOAPCallback (
SOAPServerContext *ctx, /** the SOAP context */
SOAPRequest *request, /** the action request */
void *cookie /** the UPnPService being controlled */)
{
UPnPService *service = (UPnPService *) cookie;
UPnPRootDevice *rootDevice = service->device->rootDevice;
/* first to check if the device callback is set */
if (rootDevice->userCallback)
{
/* parse the service type URI and the action name out of the
SOAPAction header string */
UPNP_CHAR *soapAction = (UPNP_CHAR *) rtp_malloc(
(rtp_strlen(request->in.soapAction) + 1) * sizeof(UPNP_CHAR));
if (soapAction)
{
UPNP_CHAR *actionName;
UPNP_CHAR *serviceTypeURI;
char *str;
/* work with a copy of the soapAction since we'll be
chopping it up */
rtp_strcpy(soapAction, request->in.soapAction);
serviceTypeURI = soapAction;
/* SOAPAction is often quote-enclosed */
if (*serviceTypeURI == '"')
{
serviceTypeURI++;
}
/* '#' signals the beginning of the action tag name */
str = rtp_strstr(serviceTypeURI, "#");
if (str)
{
long len;
RTPXML_NodeList *nodeList;
*str = 0;
str++;
actionName = str;
len = rtp_strlen(actionName);
/* remove the trailing quote if there is one */
if (actionName[len-1] == '"')
{
actionName[len-1] = 0;
}
/* the action tag must be qualified by the xml namespace
of the service type */
nodeList = rtpxmlElement_getElementsByTagNameNS (
request->in.envelope.bodyElem,
serviceTypeURI,
actionName);
if (nodeList)
{
RTPXML_Element *actionElement;
actionElement = (RTPXML_Element *) rtpxmlNodeList_item(nodeList, 0);
rtpxmlNodeList_free(nodeList);
if (actionElement)
{
UPnPActionRequest actionRequest;
rtp_memset(&actionRequest, 0, sizeof(UPnPActionRequest));
actionRequest.in.actionName = actionName;
actionRequest.in.serviceTypeURI = serviceTypeURI;
actionRequest.in.actionElement = actionElement;
actionRequest.in.serviceId = service->serviceId;
actionRequest.in.deviceUDN = service->device->UDN;
actionRequest.in.clientAddr = request->in.clientAddr;
rootDevice->userCallback(rootDevice->userData,
rootDevice->deviceRuntime,
rootDevice,
UPNP_DEVICE_EVENT_ACTION_REQUEST,
&actionRequest);
if (actionRequest.out.errorCode == 0)
{
/* success */
request->out.body = actionRequest.out.result;
rtp_free(soapAction);
return (0);
}
else
{
/* fault */
char temp[UPNP_MAX_ERROR_DESC_LEN + 176];
rtp_sprintf(temp, "<UPnPError xmlns=\"urn:schemas-upnp-org:control-1-0\">"
"<errorCode>%d</errorCode>"
"<errorDescription>%s</errorDescription>"
"</UPnPError>",
actionRequest.out.errorCode,
actionRequest.out.errorDescription);
rtp_strcpy(request->out.fault.code, "s:Client");
rtp_strcpy(request->out.fault.string, "UPnPError");
/* XML document will be freed by SOAP */
request->out.fault.detail = rtpxmlParseBuffer(temp);
rtp_free(soapAction);
return (-1);
}
}
}
}
rtp_free(soapAction);
}
}
return (-1);
}
SSDP_INT32 SSDP_SendByebye (
SSDPServerContext *ctx, /** pointer to SSDP context */
const SSDP_CHAR *notifyType, /** the notification type (NT) string */
const SSDP_CHAR *usn /** pointer to string containing USN header */)
{
SSDP_CHAR ipAddr[RTP_NET_NI_MAXHOST];
SSDP_CHAR *msgBfr;
SSDP_SOCKET notifySock = ctx->announceSocket;
if(ctx->ipType == RTP_NET_TYPE_IPV6)
{
rtp_sprintf(ipAddr, "[FF02::C]:1900");
}
else if (ctx->ipType == RTP_NET_TYPE_IPV4)
{
rtp_sprintf(ipAddr, "239.255.255.250:1900");
}
msgBfr = (SSDP_CHAR *) rtp_malloc(sizeof(SSDP_CHAR) * SSDP_BUFFER_SIZE);
if (!msgBfr)
{
return (-1);
}
/* Send Advertisements */
/* Fix (03/18/2007) - Correct formatting changed format fields from:
"HOST:%s\r\n"
"Cache-Control:max-age=%d\r\n"
"Location:%s\r\n"
"NT:%s\r\n"
"NTS:%s\r\n"
"Server:%s\r\n"
"USN:%s\r\n"
*/
#if (USE_INTEL_SDK_ORDER)
rtp_sprintf(msgBfr,"NOTIFY * HTTP/1.1\r\n"
"HOST: %s\r\n"
"NTS: ssdp:byebye\r\n"
"USN: %s\r\n"
"NT: %s\r\n"
"\r\n",
ipAddr,
usn,
notifyType);
#else
rtp_sprintf(msgBfr,"NOTIFY * HTTP/1.1\r\n"
"HOST: %s\r\n"
"NT: %s\r\n"
"NTS: ssdp:byebye\r\n"
"USN: %s\r\n"
"\r\n",
ipAddr,
notifyType,
usn);
#endif
if(ctx->ipType == RTP_NET_TYPE_IPV6)
{
rtp_strcpy(ipAddr, IPV6_LINK_LOCAL_ADDRESS);
}
else if (ctx->ipType == RTP_NET_TYPE_IPV4)
{
rtp_strcpy(ipAddr, (const char*)v4mcastAddr);
}
RTP_LOG_WRITE("SSDP_SendByeBye SEND", msgBfr, rtp_strlen(msgBfr))
/* Send the message to the multicast channel */
if (rtp_net_sendto(notifySock, (unsigned char*)msgBfr, rtp_strlen(msgBfr),(unsigned char *) ipAddr, mcastPort, ctx->ipType) < 0)
{
SSDP_ProcessError("SendTo");
rtp_free(msgBfr);
return(-1);
}
/* Free up the allocated memory */
rtp_free(msgBfr);
return(0);
}
/** @memo Read lines from a file to a buffer.
@doc Read lines from a file to buf or if the end of the file
or the line has not been reached yet, reads (buflen-1) of data.
@precondition Should not mix rtp_stdio_fread and rtpstdio_fgets
calls.
@return Number of bytes written, -1 otherwise.
*/
int rtp_stdio_fgets (
char * buf, /** Buffer to store the read. */
int buflen, /** Number of bytes to read. */
void * rtpfile /** Handle of file to be read. */
)
{
if( !rtpfile || (((RTP_STDIO_FILE *)rtpfile)->verify != RTP_FILE_VERIFICATION_VALUE) )
{
/* --------------------------------------- */
/* Application passed an RTP_HANDLE */
/* instead of an RTP_STDIO_FILE. Should */
/* use low level rtp_file_read(). */
/* --------------------------------------- */
return ((long) -1);
}
if (buflen <= 0)
{
return (-1);
}
buflen--;
if ( !(((RTP_STDIO_FILE *)rtpfile)->buffer) )
{
/* --------------------------------------- */
/* Allocate buffer. If successful, use it. */
/* --------------------------------------- */
/* --------------------------------------- */
/* Assume no line is larger than */
/* RTP_READLINE_BUFFER characters. Then we */
/* can use a buffer RTP_READLINE_BUFFER */
/* bytes and only read that many bytes at */
/* a time to speed up reading. */
/* --------------------------------------- */
((RTP_STDIO_FILE *)rtpfile)->buffer = (char *) rtp_malloc ((unsigned int)RTP_READLINE_BUFFER, 0); /* SPRZ */
if (((RTP_STDIO_FILE *)rtpfile)->buffer)
{
((RTP_STDIO_FILE *)rtpfile)->bufsiz = RTP_READLINE_BUFFER;
}
/* --------------------------------------- */
/* ((RTP_STDIO_FILE *)rtpfile)->bufpos = 0;*/
/* ((RTP_STDIO_FILE *)rtpfile)->buffil = 0;*/
/* --------------------------------------- */
}
while (((RTP_STDIO_FILE *)rtpfile)->buffer)
{
int i;
int n;
if (buflen == 0)
{
buf[0] = 0;
return (0);
}
/* --------------------------------------- */
/* check if we still got a line worth in */
/* there... */
/* --------------------------------------- */
for (i = ((RTP_STDIO_FILE *)rtpfile)->bufpos; i < ((RTP_STDIO_FILE *)rtpfile)->buffil; i++)
{
if (((RTP_STDIO_FILE *)rtpfile)->buffer[i] == '\n')
{
/* --------------------------------------- */
/* Have a line. */
/* --------------------------------------- */
i = i + 1 - ((RTP_STDIO_FILE *)rtpfile)->bufpos;
if (buflen < i)
{
i = buflen;
}
rtp_memmove(buf, ((RTP_STDIO_FILE *)rtpfile)->buffer + ((RTP_STDIO_FILE *)rtpfile)->bufpos, i);
((RTP_STDIO_FILE *)rtpfile)->bufpos += i;
buf[i] = 0;
return (i);
}
}
/* --------------------------------------- */
/* no more lines in buffer: get new data */
/* in there. FIRST: move what we've got */
/* to front. */
/* --------------------------------------- */
if (((RTP_STDIO_FILE *)rtpfile)->bufpos < ((RTP_STDIO_FILE *)rtpfile)->buffil)
{
rtp_memmove(((RTP_STDIO_FILE *)rtpfile)->buffer,
((RTP_STDIO_FILE *)rtpfile)->buffer +
((RTP_STDIO_FILE *)rtpfile)->bufpos,
((RTP_STDIO_FILE *)rtpfile)->buffil -
((RTP_STDIO_FILE *)rtpfile)->bufpos);
((RTP_STDIO_FILE *)rtpfile)->buffil -= ((RTP_STDIO_FILE *)rtpfile)->bufpos;
((RTP_STDIO_FILE *)rtpfile)->bufpos = 0;
}
else
{
((RTP_STDIO_FILE *)rtpfile)->buffil = 0;
((RTP_STDIO_FILE *)rtpfile)->bufpos = 0;
}
/* --------------------------------------- */
/* Get more data. Assume we don't mix */
/* fgets() with fread(). */
/* --------------------------------------- */
if (((((RTP_STDIO_FILE *)rtpfile)->bufsiz - ((RTP_STDIO_FILE *)rtpfile)->buffil) & ~(RTP_READLINE_BUFFER-1)) > 0)
{
/* --------------------------------------- */
/* load alligned: sector */
/* --------------------------------------- */
n = rtp_file_read (((RTP_STDIO_FILE *)rtpfile)->handle,
(unsigned char *) ((RTP_STDIO_FILE *)rtpfile)->buffer + ((RTP_STDIO_FILE *)rtpfile)->buffil,
(unsigned int) ((((RTP_STDIO_FILE *)rtpfile)->bufsiz - ((RTP_STDIO_FILE *)rtpfile)->buffil) & ~(RTP_READLINE_BUFFER-1)));
if (n > 0)
{
((RTP_STDIO_FILE *)rtpfile)->buffil += n;
/* --------------------------------------- */
/* check if we got a line worth in there. */
/* --------------------------------------- */
for (i = ((RTP_STDIO_FILE *)rtpfile)->bufpos; i < ((RTP_STDIO_FILE *)rtpfile)->buffil; i++)
{
if (((RTP_STDIO_FILE *)rtpfile)->buffer[i] == '\n')
{
/* --------------------------------------- */
/* Have line. */
/* --------------------------------------- */
i = i + 1 - ((RTP_STDIO_FILE *)rtpfile)->bufpos;
if (buflen < i)
{
i = buflen;
}
rtp_memmove(buf, ((RTP_STDIO_FILE *)rtpfile)->buffer + ((RTP_STDIO_FILE *)rtpfile)->bufpos, i);
((RTP_STDIO_FILE *)rtpfile)->bufpos += i;
buf[i] = 0;
return (i);
}
}
}
}
/* --------------------------------------- */
/* load as much as possible. */
/* --------------------------------------- */
if (((RTP_STDIO_FILE *)rtpfile)->bufsiz > ((RTP_STDIO_FILE *)rtpfile)->buffil)
{
/* --------------------------------------- */
/* load UNalligned */
/* --------------------------------------- */
n = rtp_file_read (((RTP_STDIO_FILE *)rtpfile)->handle,
(unsigned char *) ((RTP_STDIO_FILE *)rtpfile)->buffer + ((RTP_STDIO_FILE *)rtpfile)->buffil,
(unsigned int) (((RTP_STDIO_FILE *)rtpfile)->bufsiz - ((RTP_STDIO_FILE *)rtpfile)->buffil));
if (n > 0)
{
((RTP_STDIO_FILE *)rtpfile)->buffil += n;
/* --------------------------------------- */
/* check if we got a line worth in there. */
/* --------------------------------------- */
for (i = ((RTP_STDIO_FILE *)rtpfile)->bufpos; i < ((RTP_STDIO_FILE *)rtpfile)->buffil; i++)
{
if (((RTP_STDIO_FILE *)rtpfile)->buffer[i] == '\n')
{
/* --------------------------------------- */
/* Have line. */
/* --------------------------------------- */
i = i + 1 - ((RTP_STDIO_FILE *)rtpfile)->bufpos;
if (buflen < i)
{
i = buflen;
}
rtp_memmove(buf, ((RTP_STDIO_FILE *)rtpfile)->buffer + ((RTP_STDIO_FILE *)rtpfile)->bufpos, i);
((RTP_STDIO_FILE *)rtpfile)->bufpos += i;
buf[i] = 0;
return (i);
}
}
}
}
/* --------------------------------------- */
/* If we get here, the line is too long or */
/* we're stuck with the last line, which */
/* is NOT '\n' terminated. */
/* --------------------------------------- */
if (((RTP_STDIO_FILE *)rtpfile)->buffil > ((RTP_STDIO_FILE *)rtpfile)->bufpos)
{
i = ((RTP_STDIO_FILE *)rtpfile)->buffil - ((RTP_STDIO_FILE *)rtpfile)->bufpos;
if (buflen < i)
{
i = buflen;
}
rtp_memmove(buf, ((RTP_STDIO_FILE *)rtpfile)->buffer + ((RTP_STDIO_FILE *)rtpfile)->bufpos, i);
((RTP_STDIO_FILE *)rtpfile)->bufpos += i;
buf[i] = 0;
/* --------------------------------------- */
/* This may be part of a very large line. */
/* So correct pointers and everything and */
/* loop. */
/* --------------------------------------- */
buflen -= i;
buf += i;
if (buflen == 0)
{
return (0);
}
}
/* --------------------------------------- */
/* We just copied the remains of our */
/* buffer into the user buffer. Set pos to */
/* 0 and try one last ALLIGNED load to see */
/* if we still got data coming in. But */
/* shift remaining data, if any, to FRONT */
/* first. */
/* --------------------------------------- */
if (((RTP_STDIO_FILE *)rtpfile)->bufpos < ((RTP_STDIO_FILE *)rtpfile)->buffil)
{
rtp_memmove(((RTP_STDIO_FILE *)rtpfile)->buffer,
((RTP_STDIO_FILE *)rtpfile)->buffer +
((RTP_STDIO_FILE *)rtpfile)->bufpos,
((RTP_STDIO_FILE *)rtpfile)->buffil -
((RTP_STDIO_FILE *)rtpfile)->bufpos);
((RTP_STDIO_FILE *)rtpfile)->buffil -= ((RTP_STDIO_FILE *)rtpfile)->bufpos;
((RTP_STDIO_FILE *)rtpfile)->bufpos = 0;
}
else
{
((RTP_STDIO_FILE *)rtpfile)->buffil = 0;
((RTP_STDIO_FILE *)rtpfile)->bufpos = 0;
}
/* --------------------------------------- */
/* Get more data. And check if there's any */
/* left. */
/* --------------------------------------- */
/* --------------------------------------- */
/* load alligned: sector */
/* --------------------------------------- */
n = rtp_file_read (((RTP_STDIO_FILE *)rtpfile)->handle,
(unsigned char *) ((RTP_STDIO_FILE *)rtpfile)->buffer + ((RTP_STDIO_FILE *)rtpfile)->buffil,
(unsigned int) ((((RTP_STDIO_FILE *)rtpfile)->bufsiz - ((RTP_STDIO_FILE *)rtpfile)->buffil) & ~(RTP_READLINE_BUFFER-1)));
if (n > 0)
{
((RTP_STDIO_FILE *)rtpfile)->buffil += n;
}
else
{
/* --------------------------------------- */
/* EOF reached and buffer empty. */
/* --------------------------------------- */
((RTP_STDIO_FILE *)rtpfile)->eofBool = 1;
((RTP_STDIO_FILE *)rtpfile)->buffer = 0;
return (0);
}
/* --------------------------------------- */
/* we get here, iff we are reading a very */
/* long line that is larger than our */
/* '((RTP_STDIO_FILE *)rtpfile)->buffer': */
/* add next piece to output 'buf'. */
/* --------------------------------------- */
}
return (-1);
}
int _UPnP_DeviceSendRootDeviceByeBye (
UPnPRootDevice *rootDevice, /** address of the root device */
int deep /** if 1, send advertisements for all embedded devices
and services.<br>if 0, send advertisements for the
device under the root and its associated services */)
{
char notifySubType[13]; /* holds ssdp:bye-bye */
char notifyType[16]; /* holds upnp:rootdevice */
UPnPService *service;
UPnPDevice *device;
DLListNode *serviceListNode;
DLListNode *deviceListNode;
char *usn;
char *descLocation;
int result = -1;
char destAddr[RTP_NET_NI_MAXHOST];
int ipType = rootDevice->deviceRuntime->upnpRuntime->ssdpContext.ipType;
if (ipType == RTP_NET_TYPE_IPV4)
{
rtp_strcpy(destAddr, (const char *) v4mcastAddr);
}
else if (ipType == RTP_NET_TYPE_IPV6)
{
rtp_strcpy(destAddr, IPV6_LINK_LOCAL_ADDRESS);
}
descLocation = _getLocation((unsigned char *) destAddr, mcastPort, ipType, rootDevice);
if (descLocation)
{
/* allocate memory to usn to hold UDN, upnp:rootdevice, :: and a string terminator */
usn = (char *) rtp_malloc((rtp_strlen(rootDevice->device.UDN) + 18));
if (usn)
{
/* create a notify type using device UDN and device type */
rtp_strcpy(usn, rootDevice->device.UDN);
rtp_strcat(usn, "::");
rtp_strcat(usn, "upnp:rootdevice");
rtp_strcpy(notifySubType, "ssdp:bye-bye");
rtp_strcpy(notifyType, "upnp:rootdevice");
/* send root specific advertisement */
if(SSDP_SendByebye (&rootDevice->deviceRuntime->upnpRuntime->ssdpContext,
notifyType, usn) >= 0)
{
result = 0;
if (deep == 0) /* advertise the device under rootdevice and its associated services */
{
if (_UPnP_DeviceSendDeviceByeBye(&rootDevice->device) < 0)
{
result = -1;
}
if (result == 0)
{
/* advertise all services associated with this device */
serviceListNode = rootDevice->serviceList.next;
while(serviceListNode != &rootDevice->serviceList)
{
service = (UPnPService *) serviceListNode;
if (_UPnP_DeviceSendServiceByeBye(service) < 0)
{
result = -1;
break;
}
serviceListNode = serviceListNode->next;
}
if (result == 0)
{
/* advertise all devices in the device list */
deviceListNode = rootDevice->deviceList.next;
while(deviceListNode != &rootDevice->deviceList)
{
device = (UPnPDevice *)deviceListNode;
if(_UPnP_DeviceSendDeviceByeBye(device) < 0)
{
result = -1;
break;
}
deviceListNode = deviceListNode->next;
}
}
}
}
}
rtp_free(usn);
}
_freeLocation(rootDevice, descLocation);
}
return(0);
}
/**
@memo Initialize a UPnPRuntime
@doc
Initializes the given \Ref{UPnPRuntime} struct, and sets up an HTTP
server instance to receive control/event messages. This function
must be called before any other function in the UPnP SDK.
@return error code
*/
int UPnP_RuntimeInit (
UPnPRuntime* rt, /** pointer to uninitialized \Ref{UPnPRuntime} struct */
UPNP_UINT8* serverAddr, /** ip address to bind HTTP server to (NULL for IP_ADDR_ANY) */
UPNP_UINT16 serverPort, /** port to bind HTTP server to (0 for ANY_PORT) */
UPNP_INT16 ipType, /** type of ip version used (ipv4 or ipv6), (RTP_NET_TYPE_IPV4 for v4 and RTP_NET_TYPE_IPV6 for v6) */
UPNP_CHAR* wwwRootDir, /** HTTP root dir on local file system */
UPNP_INT16 maxConnections, /** the maximum limit on simultaneous HTTP server connections */
UPNP_INT16 maxHelperThreads /** if UPNP_MULTITHREAD is defined, the max number of helper threads to spawn */
)
{
HTTPServerConnection* connectCtxArray;
rt->ipType = ipType;
connectCtxArray = (HTTPServerConnection*) rtp_malloc(sizeof(HTTPServerConnection) * maxConnections);
if (connectCtxArray)
{
if (HTTP_ServerInit (
&rt->httpServer,
UPNP_SERVER_NAME, // name
wwwRootDir, // rootDir
"index.html", // defaultFile
1, // httpMajorVersion
1, // httpMinorVersion
serverAddr, // ipAddr
serverPort, // port,
ipType, // ipversion type(4 or 6)
0, // allowKeepAlive
connectCtxArray, // connectCtxArray
maxConnections, // maxConnections
maxHelperThreads // maxHelperThreads
) >= 0)
{
if (SSDP_ServerInit (
&rt->ssdpContext,
serverAddr,
ipType,
"RTPlatform/1.0, UPnP/1.0, EBS UPnPSDK/2.9",
UPnP_SSDPCallback,
rt
) >= 0)
{
#ifdef UPNP_MULTITHREAD
if (rtp_sig_mutex_alloc(&rt->mutex, 0) >= 0)
{
rt->daemonState = UPNP_DAEMON_STOPPED;
#endif /* UPNP_MULTITHREAD */
rt->deviceRuntime = 0;
rt->controlPoint = 0;
return (0);
#ifdef UPNP_MULTITHREAD
}
#endif /* UPNP_MULTITHREAD */
SSDP_ServerDestroy(&rt->ssdpContext);
}
HTTP_ServerDestroy(&rt->httpServer, &connectCtxArray);
}
rtp_free(connectCtxArray);
}
return (-1);
}
int _UPnP_DeviceSendDeviceByeBye (
UPnPDevice *device /** address of the device */)
{
char notifySubType[13]; /* holds ssdp:bye-bye */
char *usn;
char *descLocation;
int result = -1;
char destAddr[RTP_NET_NI_MAXHOST];
int ipType = device->rootDevice->deviceRuntime->upnpRuntime->ssdpContext.ipType;
/* proceed if complete device information is available */
if(!device->UDN || !device->deviceType || !device->rootDevice->descLocation)
{
return (-1);
}
if (ipType == RTP_NET_TYPE_IPV4)
{
rtp_strcpy(destAddr, (const char *) v4mcastAddr);
}
else if (ipType == RTP_NET_TYPE_IPV6)
{
rtp_strcpy(destAddr, IPV6_LINK_LOCAL_ADDRESS);
}
descLocation = _getLocation((unsigned char *) destAddr, mcastPort, ipType, device->rootDevice);
if (descLocation)
{
rtp_strcpy(notifySubType, "ssdp:bye-bye");
/* first device message of a specific device */
if(SSDP_SendByebye(&device->rootDevice->deviceRuntime->upnpRuntime->ssdpContext,
device->UDN, device->UDN) >= 0)
{
/* allocate memory to notifytype to hold UDN, devicetype, :: and a string terminator */
usn = (char *) rtp_malloc((rtp_strlen(device->UDN) + rtp_strlen(device->deviceType) + 3));
if (usn)
{
/* create a notify type using device UDN and device type */
rtp_strcpy(usn, device->UDN);
rtp_strcat(usn, "::");
rtp_strcat(usn, device->deviceType);
/* Second device message of a specific device */
if(SSDP_SendByebye(&device->rootDevice->deviceRuntime->upnpRuntime->ssdpContext,
device->UDN, device->UDN) >= 0)
{
result = 0;
}
rtp_free(usn);
}
}
_freeLocation(device->rootDevice, descLocation);
}
return (result);
}
