CStdString MythProgramInfo::ProgramID()
{
char* progId = cmyth_proginfo_programid(*m_proginfo_t);
CStdString retval(progId);
ref_release(progId);
return retval;
}
void
cmyth_recordingrule_set_subtitle(cmyth_recordingrule_t rr, char *subtitle)
{
if (rr->subtitle)
ref_release(rr->subtitle);
rr->subtitle = ref_strdup(subtitle);
}
void
cmyth_recordingrule_set_storagegroup(cmyth_recordingrule_t rr, char *storagegroup)
{
if (rr->storagegroup)
ref_release(rr->storagegroup);
rr->storagegroup = ref_strdup(storagegroup);
}
void
cmyth_recordingrule_set_starttime(cmyth_recordingrule_t rr, time_t starttime)
{
if (rr->starttime)
ref_release(rr->starttime);
rr->starttime = cmyth_timestamp_from_unixtime(starttime);
}
void
cmyth_recordingrule_set_description(cmyth_recordingrule_t rr, char *description)
{
if (rr->description)
ref_release(rr->description);
rr->description = ref_strdup(description);
}
CStdString MythRecordingRule::Callsign() const
{
char *buf = cmyth_recordingrule_callsign(*m_recordingrule_t);
CStdString retval(buf);
ref_release(buf);
return retval;
}
void run(char *conf_file) {
struct running rr;
struct event *sig1_ev,*sig2_ev,*sig_hup;
evthread_use_pthreads();
setup_running(&rr);
register_interface_types(&rr);
register_source_types(&rr);
run_config(&rr,conf_file);
start_stats_timer(&rr);
ref_release(&(rr.ic_running));
event_add(sq_consumer(rr.sq),0);
event_add(si_consumer(rr.si),0);
sq_release(rr.sq);
evsignal_add(sig1_ev=evsignal_new(rr.eb,SIGINT,user_quit,&rr),0);
evsignal_add(sig2_ev=evsignal_new(rr.eb,SIGTERM,user_quit,&rr),0);
evsignal_add(sig_hup=evsignal_new(rr.eb,SIGHUP,hupev,&rr),0);
rr.sigkill_timer = event_new(rr.eb,-1,EV_PERSIST,sigkill_self,&rr);
log_info(("Starting event loop"));
event_base_loop(rr.eb,0);
log_info(("Event loop finished"));
event_del(sig1_ev);
event_del(sig2_ev);
event_del(sig_hup);
event_free(sig1_ev);
event_free(sig2_ev);
event_free(sig_hup);
closedown(&rr);
log_info(("Bye!"));
config_finished();
}
/**
* Allocate a dynamic query string to have parameters added to it
* \param db database connection object
* \param query_string Query string with ? placemarks for all dynamic
* parameters, this is NOT copied and must therefore
* remain valid for the life of the query.
*/
cmyth_mysql_query_t *
cmyth_mysql_query_create(cmyth_database_t db, const char * query_string)
{
cmyth_mysql_query_t * out;
out = ref_alloc(sizeof(*out));
if(out != NULL)
{
ref_set_destroy(out,query_destroy);
out->source = out->source_pos = query_string;
out->source_len = strlen(out->source);
out->buf_size = out->source_len *2;
out->buf_used = 0;
out->db = ref_hold(db);
out->buf = ref_alloc(out->buf_size);
if(out->buf == NULL)
{
ref_release(out);
out = NULL;
}
else
{
out->buf[0] = '\0';
}
}
return out;
}
void
cmyth_recordingrule_set_profile(cmyth_recordingrule_t rr, char *profile)
{
if (rr->profile)
ref_release(rr->profile);
rr->profile = ref_strdup(profile);
}
MYSQL_RES *
cmyth_mysql_query_result(cmyth_mysql_query_t * query)
{
MYSQL_RES * retval = NULL;
int ret;
char * query_str;
MYSQL *mysql = cmyth_db_get_connection(query->db);
if(mysql == NULL)
return NULL;
query_str = cmyth_mysql_query_string(query);
if(query_str == NULL)
return NULL;
ret = mysql_query(mysql,query_str);
ref_release(query_str);
if(ret != 0)
{
cmyth_dbg(CMYTH_DBG_ERROR, "%s: mysql_query(%s) Failed: %s\n",
__FUNCTION__, query_str, mysql_error(mysql));
return NULL;
}
retval = mysql_store_result(mysql);
if(retval == NULL)
{
cmyth_dbg(CMYTH_DBG_ERROR, "%s: mysql_use_result Failed: %s\n",
__FUNCTION__, query_str, mysql_error(mysql));
}
return retval;
}
/**
* Internal only! Registered as callback to de-allocate actual buffer if
* the query is de-allocated
* \param p pointer to the query data structure
*/
static void
query_destroy(void *p)
{
cmyth_mysql_query_t * query = (cmyth_mysql_query_t *)p;
if(query->buf != NULL)
{
ref_release(query->buf);
query->buf = NULL;
query->buf_size = 0;
}
if(query->db != NULL)
{
ref_release(query->db);
query->db = NULL;
}
}
static int
get_event(char *host)
{
struct timeval tv;
cmyth_conn_t event;
if ((event=cmyth_conn_connect_event(host, 6543,
16*1024, 4096)) == NULL) {
return -1;
}
tv.tv_sec = 1;
tv.tv_usec = 0;
if (cmyth_event_select(event, &tv) > 0) {
cmyth_event_t e;
char data[128];
memset(data, 0, sizeof(data));
e = cmyth_event_get(event, data, sizeof(data));
printf("Event: %d '%s'\n", e, data);
}
ref_release(event);
return 0;
}
CStdString MythProgramInfo::Path()
{
char* path = cmyth_proginfo_pathname(*m_proginfo_t);
CStdString retval(path);
ref_release(path);
return retval;
}
CStdString MythProgramInfo::Subtitle()
{
char* subtitle = cmyth_proginfo_subtitle(*m_proginfo_t);
CStdString retval(subtitle);
ref_release(subtitle);
return retval;
}
CStdString MythRecordingRule::StorageGroup() const
{
char *buf = cmyth_recordingrule_storagegroup(*m_recordingrule_t);
CStdString retval(buf);
ref_release(buf);
return retval;
}
void
cmyth_recordingrule_set_programid(cmyth_recordingrule_t rr, char *programid)
{
if (rr->programid)
ref_release(rr->programid);
rr->programid = ref_strdup(programid);
}
CStdString MythRecordingRule::PlaybackGroup() const
{
char *buf = cmyth_recordingrule_playgroup(*m_recordingrule_t);
CStdString retval(buf);
ref_release(buf);
return retval;
}
void
cmyth_recordingrule_set_seriesid(cmyth_recordingrule_t rr, char *seriesid)
{
if (rr->seriesid)
ref_release(rr->seriesid);
rr->seriesid = ref_strdup(seriesid);
}
int
cmyth_chain_set_current(cmyth_chain_t chain, cmyth_proginfo_t prog)
{
unsigned int i;
int rc = -1;
void (*callback)(cmyth_proginfo_t prog) = NULL;
cmyth_proginfo_t cb_prog = NULL;
if ((chain == NULL) || (prog == NULL)) {
return -1;
}
pthread_mutex_lock(&chain->chain_mutex);
for (i=0; i<chain->chain_count; i++) {
if (cmyth_proginfo_compare(prog,
chain->chain_list[i]->prog) == 0) {
chain->chain_current = i;
callback = chain->chain_callback;
if (callback) {
cb_prog = ref_hold(chain->chain_list[i]->prog);
}
break;
}
}
pthread_mutex_unlock(&chain->chain_mutex);
if (callback && cb_prog) {
callback(cb_prog);
ref_release(cb_prog);
}
return rc;
}
void
cmyth_recordingrule_set_inetref(cmyth_recordingrule_t rr, char *inetref)
{
if (rr->inetref)
ref_release(rr->inetref);
rr->inetref = ref_strdup(inetref);
}
void
cmyth_recordingrule_set_callsign(cmyth_recordingrule_t rr, char *callsign)
{
if (rr->callsign)
ref_release(rr->callsign);
rr->callsign = ref_strdup(callsign);
}
/*
* cmyth_recorder_get_next_proginfo(cmyth_recorder_t rec,
* cmyth_proginfo_t current,
* cmyth_browsedir_t direction)
*
* Scope: PUBLIC
*
* Description:
*
* Request program information from the recorder 'rec' for the next
* program in the program guide from the current program (i.e. current
* channel and time slot) in the direction specified by 'direction'
* which may have any of the following values:
*
* BROWSE_DIRECTION_SAME - Stay in the same place
* BROWSE_DIRECTION_UP - Move up one slot (down one channel)
* BROWSE_DIRECTION_DOWN - Move down one slot (up one channel)
* BROWSE_DIRECTION_LEFT - Move left one slot (down one time slot)
* BROWSE_DIRECTION_RIGHT - Move right one slot (up one time slot)
* BROWSE_DIRECTION_FAVORITE - Move to the next favorite slot
*
* This does not affect the current recording.
*
* Return Value:
*
* Success: A held non-NULL cmyth_proginfo_t
* Failure: A NULL pointer
*/
cmyth_proginfo_t
cmyth_recorder_get_next_proginfo(cmyth_recorder_t rec,
cmyth_proginfo_t current,
cmyth_browsedir_t direction)
{
cmyth_proginfo_t ret;
if (!rec || !current) {
cmyth_dbg(CMYTH_DBG_ERROR, "%s: invalid args "
"rec =%p, current = %p\n",
__FUNCTION__, rec, current);
return NULL;
}
ret = cmyth_proginfo_create();
if (ret == NULL) {
cmyth_dbg(CMYTH_DBG_ERROR,
"%s: cmyth_proginfo_create() failed\n",
__FUNCTION__);
return NULL;
}
if (cmyth_recorder_get_next_program_info(rec, current,
ret, direction) < 0) {
cmyth_dbg(CMYTH_DBG_ERROR,
"%s: cmyth_recorder_get_next_program_info()\n",
__FUNCTION__);
ref_release(ret);
return NULL;
}
return ret;
}
void
cmyth_recordingrule_set_endtime(cmyth_recordingrule_t rr, time_t endtime)
{
if (rr->endtime)
ref_release(rr->endtime);
rr->endtime = cmyth_timestamp_from_unixtime(endtime);
}
int
cmyth_conn_connect_recorder(cmyth_recorder_t rec, unsigned buflen,
int tcp_rcvbuf)
{
cmyth_conn_t conn;
char *server;
unsigned short port;
if (!rec) {
cmyth_dbg(CMYTH_DBG_ERROR, "%s: rec is NULL\n", __FUNCTION__);
return -1;
}
server = rec->rec_server;
port = rec->rec_port;
cmyth_dbg(CMYTH_DBG_PROTO, "%s: connecting recorder control\n",
__FUNCTION__);
conn = cmyth_conn_connect_ctrl(server, port, buflen, tcp_rcvbuf);
cmyth_dbg(CMYTH_DBG_PROTO,
"%s: done connecting recorder control, conn = %p\n",
__FUNCTION__, conn);
if (!conn) {
cmyth_dbg(CMYTH_DBG_ERROR,
"%s: cmyth_connect(%s, %d, %d) failed\n",
__FUNCTION__, server, port, buflen);
return -1;
}
if (rec->rec_conn)
ref_release(rec->rec_conn);
rec->rec_conn = conn;
return 0;
}
void
cmyth_recordingrule_set_category(cmyth_recordingrule_t rr, char *category)
{
if (rr->category)
ref_release(rr->category);
rr->category = ref_strdup(category);
}
CStdString MythRecordingRule::Subtitle() const
{
char *buf = cmyth_recordingrule_subtitle(*m_recordingrule_t);
CStdString retval(buf);
ref_release(buf);
return retval;
}
void
cmyth_recordingrule_set_recgroup(cmyth_recordingrule_t rr, char *recgroup)
{
if (rr->recgroup)
ref_release(rr->recgroup);
rr->recgroup = ref_strdup(recgroup);
}
CStdString MythRecordingRule::Description() const
{
char *buf = cmyth_recordingrule_description(*m_recordingrule_t);
CStdString retval(buf);
ref_release(buf);
return retval;
}
void
cmyth_recordingrule_set_playgroup(cmyth_recordingrule_t rr, char *playgroup)
{
if (rr->playgroup)
ref_release(rr->playgroup);
rr->playgroup = ref_strdup(playgroup);
}
CStdString MythProgramInfo::RecordingGroup()
{
char* recgroup = cmyth_proginfo_recgroup(*m_proginfo_t);
CStdString retval(recgroup);
ref_release(recgroup);
return retval;
}
