void
tvhdhomerun_device_destroy( tvhdhomerun_device_t *hd )
{
tvhdhomerun_frontend_t *lfe;
lock_assert(&global_lock);
gtimer_disarm(&hd->hd_destroy_timer);
gtimer_disarm(&tvhdhomerun_discovery_timer);
tvhlog(LOG_INFO, "tvhdhomerun", "Releaseing locks for devices");
while ((lfe = TAILQ_FIRST(&hd->hd_frontends)) != NULL) {
tvhdhomerun_frontend_delete(lfe);
}
#define FREEM(x) free(hd->hd_info.x)
FREEM(ip_address);
FREEM(friendlyname);
FREEM(uuid);
FREEM(deviceModel);
#undef FREEM
tvh_hardware_delete((tvh_hardware_t*)hd);
#define FREEM(x) free(hd->x)
FREEM(hd_override_type);
#undef FREEM
free(hd);
hdhomerun_debug_destroy(hdhomerun_debug_obj);
}
void
download_done( download_t *dn )
{
if (dn->http_client) {
http_client_close(dn->http_client);
dn->http_client = NULL;
}
download_pipe_close(dn);
gtimer_disarm(&dn->fetch_timer);
gtimer_disarm(&dn->pipe_read_timer);
free(dn->log); dn->log = NULL;
free(dn->url); dn->url = NULL;
}
/*
* Stop connection
*/
static void
iptv_rtsp_stop
( iptv_mux_t *im )
{
rtsp_priv_t *rp = im->im_data;
int play;
lock_assert(&global_lock);
if (rp == NULL)
return;
play = rp->play;
im->im_data = NULL;
rp->hc->hc_aux = NULL;
if (play)
rtsp_teardown(rp->hc, rp->path, "");
pthread_mutex_unlock(&iptv_lock);
gtimer_disarm(&rp->alive_timer);
udp_multirecv_free(&rp->um);
if (!play)
http_client_close(rp->hc);
free(rp->path);
free(rp->query);
rtcp_destroy(rp->rtcp_info);
free(rp->rtcp_info);
free(rp);
pthread_mutex_lock(&iptv_lock);
}
static int
download_pipe(download_t *dn, const char *args)
{
char **argv = NULL;
int r;
download_pipe_close(dn);
gtimer_disarm(&dn->pipe_read_timer);
/* Arguments */
if (spawn_parse_args(&argv, 64, args, NULL)) {
tvherror(dn->log, "pipe: unable to parse arguments (%s)", args);
return -1;
}
/* Grab */
r = spawn_and_give_stdout(argv[0], argv, NULL, &dn->pipe_fd, &dn->pipe_pid, 1);
spawn_free_args(argv);
if (r < 0) {
dn->pipe_fd = -1;
dn->pipe_pid = 0;
tvherror(dn->log, "pipe: cannot start (%s)", args);
return -1;
}
fcntl(dn->pipe_fd, F_SETFL, fcntl(dn->pipe_fd, F_GETFL) | O_NONBLOCK);
gtimer_arm_ms(&dn->pipe_read_timer, download_pipe_read, dn, 250);
return 0;
}
static void
epggrab_ota_done ( epggrab_ota_mux_t *om, int reason )
{
static const char *reasons[] = {
[EPGGRAB_OTA_DONE_COMPLETE] = "complete",
[EPGGRAB_OTA_DONE_TIMEOUT] = "timeout",
[EPGGRAB_OTA_DONE_NO_DATA] = "no data",
[EPGGRAB_OTA_DONE_STOLEN] = "stolen"
};
char name[256];
mpegts_mux_t *mm;
epggrab_ota_map_t *map;
if (om->om_save)
epggrab_ota_save(om);
mm = mpegts_mux_find(om->om_mux_uuid);
mpegts_mux_nice_name(mm, name, sizeof(name));
tvhdebug("epggrab", "grab done for %s (%s)", name, reasons[reason]);
gtimer_disarm(&om->om_timer);
gtimer_disarm(&om->om_data_timer);
assert(om->om_q_type == EPGGRAB_OTA_MUX_ACTIVE);
TAILQ_REMOVE(&epggrab_ota_active, om, om_q_link);
om->om_q_type = EPGGRAB_OTA_MUX_IDLE;
if (reason == EPGGRAB_OTA_DONE_STOLEN) {
/* Do not requeue completed muxes */
if (!om->om_done && om->om_requeue) {
TAILQ_INSERT_HEAD(&epggrab_ota_pending, om, om_q_link);
om->om_q_type = EPGGRAB_OTA_MUX_PENDING;
} else {
om->om_requeue = 0;
}
} else if (reason == EPGGRAB_OTA_DONE_TIMEOUT) {
om->om_requeue = 0;
LIST_FOREACH(map, &om->om_modules, om_link)
if (!map->om_complete)
tvhlog(LOG_WARNING, "epggrab", "%s - data completion timeout for %s", map->om_module->name, name);
} else {
void
mpegts_network_scan_queue_del ( mpegts_mux_t *mm )
{
mpegts_network_t *mn = mm->mm_network;
if (mm->mm_scan_state == MM_SCAN_STATE_ACTIVE) {
TAILQ_REMOVE(&mn->mn_scan_active, mm, mm_scan_link);
} else if (mm->mm_scan_state == MM_SCAN_STATE_PEND) {
TAILQ_REMOVE(&mn->mn_scan_pend, mm, mm_scan_link);
}
mm->mm_scan_state = MM_SCAN_STATE_IDLE;
mm->mm_scan_weight = 0;
gtimer_disarm(&mm->mm_scan_timeout);
gtimer_arm(&mn->mn_scan_timer, mpegts_network_scan_timer_cb, mn, 0);
mpegts_network_scan_notify(mm);
}
void
mpegts_network_scan_queue_del ( mpegts_mux_t *mm )
{
mpegts_network_t *mn = mm->mm_network;
char buf[256], buf2[256];
if (mm->mm_scan_state == MM_SCAN_STATE_ACTIVE) {
TAILQ_REMOVE(&mn->mn_scan_active, mm, mm_scan_link);
} else if (mm->mm_scan_state == MM_SCAN_STATE_PEND) {
TAILQ_REMOVE(&mn->mn_scan_pend, mm, mm_scan_link);
}
mpegts_mux_nice_name(mm, buf, sizeof(buf));
mn->mn_display_name(mn, buf2, sizeof(buf2));
tvhdebug("mpegts", "%s - removing mux %s from scan queue", buf2, buf);
mm->mm_scan_state = MM_SCAN_STATE_IDLE;
mm->mm_scan_weight = 0;
gtimer_disarm(&mm->mm_scan_timeout);
gtimer_arm(&mn->mn_scan_timer, mpegts_network_scan_timer_cb, mn, 0);
mpegts_network_scan_notify(mm);
}
void
satip_device_destroy( satip_device_t *sd )
{
satip_frontend_t *lfe;
lock_assert(&global_lock);
gtimer_disarm(&sd->sd_destroy_timer);
while ((lfe = TAILQ_FIRST(&sd->sd_frontends)) != NULL)
satip_frontend_delete(lfe);
satip_device_dbus_notify(sd, "stop");
#define FREEM(x) free(sd->sd_info.x)
FREEM(myaddr);
FREEM(addr);
FREEM(uuid);
FREEM(bootid);
FREEM(configid);
FREEM(deviceid);
FREEM(location);
FREEM(server);
FREEM(friendlyname);
FREEM(manufacturer);
FREEM(manufacturerURL);
FREEM(modeldesc);
FREEM(modelname);
FREEM(modelnum);
FREEM(serialnum);
FREEM(presentation);
FREEM(tunercfg);
#undef FREEM
free(sd->sd_bindaddr);
free(sd->sd_tunercfg);
tvh_hardware_delete((tvh_hardware_t*)sd);
free(sd);
}
