int TvDeviceHandleSubscriptionRequest(const UpnpSubscriptionRequest *sr_event)
{
unsigned int i = 0;
int cmp1 = 0;
int cmp2 = 0;
const char *l_serviceId = NULL;
const char *l_udn = NULL;
const char *l_sid = NULL;
/* lock state mutex */
ithread_mutex_lock(&TVDevMutex);
l_serviceId = UpnpString_get_String(UpnpSubscriptionRequest_get_ServiceId(sr_event));
l_udn = UpnpSubscriptionRequest_get_UDN_cstr(sr_event);
l_sid = UpnpSubscriptionRequest_get_SID_cstr(sr_event);
for (i = 0; i < TV_SERVICE_SERVCOUNT; ++i) {
cmp1 = strcmp(l_udn, tv_service_table[i].UDN);
cmp2 = strcmp(l_serviceId, tv_service_table[i].ServiceId);
if (cmp1 == 0 && cmp2 == 0) {
#if 0
PropSet = NULL;
for (j = 0; j < tv_service_table[i].VariableCount; ++j) {
/* add each variable to the property set */
/* for initial state dump */
UpnpAddToPropertySet(&PropSet,
tv_service_table[i].
VariableName[j],
tv_service_table[i].
VariableStrVal[j]);
}
/* dump initial state */
UpnpAcceptSubscriptionExt(device_handle,
l_udn,
l_serviceId, PropSet, l_sid);
/* free document */
Document_free(PropSet);
#endif
UpnpAcceptSubscription(device_handle,
l_udn,
l_serviceId,
(const char **)
tv_service_table[i].VariableName,
(const char **)
tv_service_table
[i].VariableStrVal,
tv_service_table[i].
VariableCount, l_sid);
}
}
ithread_mutex_unlock(&TVDevMutex);
return 1;
}
static int handle_subscription_request(struct device_private *priv,
struct Upnp_Subscription_Request
*sr_event)
{
struct service *srv;
int i;
int eventVarCount = 0, eventVarIdx = 0;
const char **eventvar_names;
const char **eventvar_values;
int rc;
int result = -1;
ENTER();
assert(priv != NULL);
printf("Subscription request\n");
printf(" %s\n", sr_event->UDN);
printf(" %s\n", sr_event->ServiceId);
srv = find_service(priv->upnp_device, sr_event->ServiceId);
if (srv == NULL) {
fprintf(stderr, "%s: Unknown service '%s'\n", __FUNCTION__,
sr_event->ServiceId);
goto out;
}
ithread_mutex_lock(&(priv->device_mutex));
/* generate list of eventable variables */
for(i=0; i<srv->variable_count; i++) {
struct var_meta *metaEntry;
metaEntry = &(srv->variable_meta[i]);
if (metaEntry->sendevents == SENDEVENT_YES) {
eventVarCount++;
}
}
eventvar_names = malloc((eventVarCount+1) * sizeof(const char *));
eventvar_values = malloc((eventVarCount+1) * sizeof(const char *));
printf("%d evented variables\n", eventVarCount);
for(i=0; i<srv->variable_count; i++) {
struct var_meta *metaEntry;
metaEntry = &(srv->variable_meta[i]);
if (metaEntry->sendevents == SENDEVENT_YES) {
eventvar_names[eventVarIdx] = srv->variable_names[i];
// Do these need to be xml-escpaed ?
eventvar_values[eventVarIdx] = xmlescape(srv->variable_values[i], 0);
printf("Subscribe to '%s' == '%s'\n",
eventvar_names[eventVarIdx],
eventvar_values[eventVarIdx]);
eventVarIdx++;
}
}
eventvar_names[eventVarIdx] = NULL;
eventvar_values[eventVarIdx] = NULL;
rc = UpnpAcceptSubscription(priv->device_handle,
sr_event->UDN, sr_event->ServiceId,
eventvar_names, eventvar_values, eventVarCount,
sr_event->Sid);
if (rc == UPNP_E_SUCCESS) {
result = 0;
}
ithread_mutex_unlock(&(priv->device_mutex));
for (i = 0; i < eventVarCount; ++i) {
// Allocated by xmlescape()
free((char*)eventvar_values[i]);
}
free(eventvar_names);
free(eventvar_values);
out:
LEAVE();
return result;
}
static int handle_subscription_request(struct upnp_device *priv,
struct Upnp_Subscription_Request
*sr_event)
{
struct service *srv;
int rc;
assert(priv != NULL);
Log_info("upnp", "Subscription request for %s (%s)",
sr_event->ServiceId, sr_event->UDN);
srv = find_service(priv->upnp_device_descriptor, sr_event->ServiceId);
if (srv == NULL) {
Log_error("upnp", "%s: Unknown service '%s'", __FUNCTION__,
sr_event->ServiceId);
return -1;
}
int result = -1;
ithread_mutex_lock(&(priv->device_mutex));
// There is really only one variable evented: LastChange
const char *eventvar_names[] = {
"LastChange",
NULL
};
const char *eventvar_values[] = {
NULL, NULL
};
// Build the current state of the variables as one gigantic initial
// LastChange update.
ithread_mutex_lock(srv->service_mutex);
const int var_count =
VariableContainer_get_num_vars(srv->variable_container);
// TODO(hzeller): maybe use srv->last_change directly ?
upnp_last_change_builder_t *builder = UPnPLastChangeBuilder_new(srv->event_xml_ns);
for (int i = 0; i < var_count; ++i) {
const char *name;
const char *value =
VariableContainer_get(srv->variable_container, i, &name);
// Send over all variables except "LastChange" itself. Also all
// A_ARG_TYPE variables are not evented.
if (value && strcmp("LastChange", name) != 0
&& strncmp("A_ARG_TYPE_", name, strlen("A_ARG_TYPE_")) != 0) {
UPnPLastChangeBuilder_add(builder, name, value);
}
}
ithread_mutex_unlock(srv->service_mutex);
char *xml_value = UPnPLastChangeBuilder_to_xml(builder);
Log_info("upnp", "Initial variable sync: %s", xml_value);
eventvar_values[0] = xmlescape(xml_value, 0);
free(xml_value);
UPnPLastChangeBuilder_delete(builder);
rc = UpnpAcceptSubscription(priv->device_handle,
sr_event->UDN, sr_event->ServiceId,
eventvar_names, eventvar_values, 1,
sr_event->Sid);
if (rc == UPNP_E_SUCCESS) {
result = 0;
} else {
Log_error("upnp", "Accept Subscription Error: %s (%d)",
UpnpGetErrorMessage(rc), rc);
}
ithread_mutex_unlock(&(priv->device_mutex));
free((char*)eventvar_values[0]);
return result;
}
static int handle_subscription_request(struct Upnp_Subscription_Request
*sr_event)
{
struct service *srv;
int i;
int eventVarCount = 0, eventVarIdx = 0;
const char **eventvar_names = NULL;
char **eventvar_values = NULL;
int rc;
int result = -1;
ENTER();
srv = find_service(upnp_device, sr_event->ServiceId);
if (srv == NULL) {
debug_printf(MSG_ERROR, "%s: Unknown service '%s'\n", __FUNCTION__,
sr_event->ServiceId);
goto out;
}
ithread_mutex_lock(&(upnp_device->device_mutex));
/* generate list of eventable variables */
for(i=0; i<srv->variable_count; i++) {
struct var_meta *metaEntry;
metaEntry = &(srv->variable_meta[i]);
if (metaEntry->sendevents == SENDEVENT_YES) {
eventVarCount++;
}
}
eventvar_names = malloc((eventVarCount+1) * sizeof(const char *));
if (NULL == eventvar_names)
{
debug_printf(MSG_ERROR,
"eventvar_names malloc fail, eventVarCount:%d\n",
eventVarCount);
return 1;
}
eventvar_values = malloc((eventVarCount+1) * sizeof(const char *));
if (NULL == eventvar_values)
{
debug_printf(MSG_ERROR,
"eventvar_values malloc fail, eventVarCount:%d\n",
eventVarCount);
free(eventvar_names);
return 1;
}
//printf("%d evented variables\n", eventVarCount);
for(i=0; i<srv->variable_count; i++) {
struct var_meta *metaEntry;
metaEntry = &(srv->variable_meta[i]);
if (metaEntry->sendevents == SENDEVENT_YES) {
eventvar_names[eventVarIdx] = srv->variable_names[i];
eventvar_values[eventVarIdx] = xmlescape(srv->variable_values[i], 0);
//printf("Evented: '%s' == '%s'\n",
// eventvar_names[eventVarIdx],
// eventvar_values[eventVarIdx]);
eventVarIdx++;
}
}
eventvar_names[eventVarIdx] = NULL;
eventvar_values[eventVarIdx] = NULL;
rc = UpnpAcceptSubscription(device_handle,
sr_event->UDN, sr_event->ServiceId,
(const char **)eventvar_names,
(const char **)eventvar_values,
eventVarCount,
sr_event->Sid);
if (rc == UPNP_E_SUCCESS) {
result = 0;
}
ithread_mutex_unlock(&(upnp_device->device_mutex));
for(i=0; i<eventVarCount; i++) {
free(eventvar_values[i]);
}
free(eventvar_names);
free(eventvar_values);
out:
LEAVE();
return result;
}
