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; }