char *
cmyth_proginfo_playgroup(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL playgroup\n",
			  __FUNCTION__);
		return NULL;
	}
	return ref_hold(prog->proginfo_playgroup);
}

cmyth_timestamp_t
cmyth_proginfo_originalairdate(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL original air date\n",
			  __FUNCTION__);
		return NULL;
	}
	return ref_hold(prog->proginfo_originalairdate);
}

/*
 * cmyth_recorder_is_recording(cmyth_recorder_t rec)
 * 
 * Scope: PUBLIC
 *
 * Description
 *
 * Determine whether recorder 'rec' is currently recording.  Return
 * the true / false answer.
 *
 * Return Value:
 *
 * Success: 0 if the recorder is idle, 1 if the recorder is recording.
 *
 * Failure: -(ERRNO)
 */
int
cmyth_recorder_is_recording(cmyth_recorder_t rec)
{
	int err, count;
	int r;
	long c, ret;
	char msg[256];

	if (!rec) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: no recorder connection\n",
			  __FUNCTION__);
		return -EINVAL;
	}

	pthread_mutex_lock(&mutex);

	snprintf(msg, sizeof(msg), "QUERY_RECORDER %u[]:[]IS_RECORDING",
		 rec->rec_id);

	if ((err=cmyth_send_message(rec->rec_conn, msg)) < 0) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_send_message() failed (%d)\n",
			  __FUNCTION__, err);
		ret = err;
		goto out;
	}

	count = cmyth_rcv_length(rec->rec_conn);
	if ((r=cmyth_rcv_long(rec->rec_conn, &err, &c, count)) < 0) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_rcv_length() failed (%d)\n",
			  __FUNCTION__, r);
		ret = err;
		goto out;
	}

	ret = c;

    out:
	pthread_mutex_unlock(&mutex);

	return ret;
}

/*
 * cmyth_chanlist_get_count()
 *
 * Scope: PUBLIC
 *
 * Description:
 *
 * Retrieve the number of elements in the channels list
 * structure in 'cl'.
 *
 * Return Value:
 *
 * Success: A number >= 0 indicating the number of items in 'cl'
 *
 * Failure: -(errno)
 */
int
cmyth_chanlist_get_count(cmyth_chanlist_t cl)
{
	if (!cl) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL program list\n",
			  __FUNCTION__);
		return -EINVAL;
	}
	return cl->chanlist_count;
}

char *
cmyth_proginfo_seriesid(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL series ID\n",
			  __FUNCTION__);
		return NULL;
	}
	return ref_hold(prog->proginfo_seriesid);
}

/*
 * cmyth_proginfo_category(cmyth_proginfo_t prog)
 *
 *
 * Scope: PUBLIC
 *
 * Description
 *
 * Retrieves the 'proginfo_category' field of a program info structure.
 *
 * The returned string is a pointer to the string within the program
 * info structure, so it should not be modified by the caller.  The
 * return value is a 'char *' for this reason.
 *
 * Return Value:
 *
 * Success: A pointer to a 'char *' pointing to the field.
 *
 * Failure: NULL
 */
char *
cmyth_proginfo_category(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL program information\n",
			  __FUNCTION__);
		return NULL;
	}
	return ref_hold(prog->proginfo_category);
}

/*
 * cmyth_recordingrulelist_get_count()
 *
 * Scope: PUBLIC
 *
 * Description:
 *
 * Retrieve the number of elements in the recording schedule list
 * structure in 'rrl'.
 *
 * Return Value:
 *
 * Success: A number >= 0 indicating the number of items in 'rrl'
 *
 * Failure: -(errno)
 */
int
cmyth_recordingrulelist_get_count(cmyth_recordingrulelist_t rrl)
{
	if (!rrl) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL recordingrule list\n",
			  __FUNCTION__);
		return -EINVAL;
	}
	return rrl->recordingrulelist_count;
}

char *
cmyth_proginfo_stars(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL stars\n",
			  __FUNCTION__);
		return NULL;
	}
	return ref_hold(prog->proginfo_stars);
}

char *
cmyth_proginfo_inetref(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL inetref\n",
			  __FUNCTION__);
		return NULL;
	}
	return ref_hold(prog->proginfo_inetref);
}

int
cmyth_recorder_done_ringbuf(cmyth_recorder_t rec)
{
	int err;
	int ret = -1;
	char msg[256];

	if (!rec) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: no recorder connection\n",
			  __FUNCTION__);
		return -ENOSYS;
	}

	if(rec->rec_conn->conn_version >= 26)
		return 0;

	pthread_mutex_lock(&mutex);

	snprintf(msg, sizeof(msg), "QUERY_RECORDER %"PRIu32"[]:[]DONE_RINGBUF",
		 rec->rec_id);

	if ((err=cmyth_send_message(rec->rec_conn, msg)) < 0) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_send_message() failed (%d)\n",
			  __FUNCTION__, err);
		goto fail;
	}

	if ((err=cmyth_rcv_okay(rec->rec_conn)) < 0) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_rcv_okay() failed (%d)\n",
			  __FUNCTION__, err);
		goto fail;
	}

	ret = 0;

    fail:
	pthread_mutex_unlock(&mutex);

	return ret;
}

/*
 * cmyth_recorder_check_channel(cmyth_recorder_t rec, char *channame)
 * 
 * Scope: PUBLIC
 *
 * Description
 *
 * Request that the recorder 'rec' check the validity of the channel
 * specified by 'channame'.
 *
 * Return Value:
 *
 * Check the validity of a channel name.
 * Success: 1 - valid channel, 0 - invalid channel
 *
 * Failure: -(ERRNO)
 */
int
cmyth_recorder_check_channel(cmyth_recorder_t rec,
                             char *channame)
{
	int err;
	int ret = -1;
	char msg[256];

	if (!rec || !channame) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: invalid args "
			  "rec = %p, channame = %p\n",
			  __FUNCTION__, rec, channame);
		return -EINVAL;
	}

	pthread_mutex_lock(&rec->rec_conn->conn_mutex);

	snprintf(msg, sizeof(msg),
		 "QUERY_RECORDER %d[]:[]CHECK_CHANNEL[]:[]%s",
		 rec->rec_id, channame);

	if ((err=cmyth_send_message(rec->rec_conn, msg)) < 0) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_send_message() failed (%d)\n",
			  __FUNCTION__, err);
		goto fail;
	}

	if ((err=cmyth_rcv_match(rec->rec_conn, "1")) < 0) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_rcv_match() failed (%d)\n",
			  __FUNCTION__, err);
		goto fail;
	}

	ret = 0;

    fail:
	pthread_mutex_unlock(&rec->rec_conn->conn_mutex);

	return ret;
}

/*
 * cmyth_timestamp_to_isostring(char *str, cmyth_timestamp_t ts)
 *
 * Scope: PUBLIC
 *
 * Description
 *
 * Create a string from the timestamp structure 'ts' and put it in the
 * user supplied buffer 'str'.  The size of 'str' must be
 * CMYTH_TIMESTAMP_LEN + 1 or this will overwrite beyond 'str'.
 *
 *
 * Return Value:
 *
 * Success: 0
 *
 * Failure: -(ERRNO)
 */
int
cmyth_timestamp_to_isostring(char *str, cmyth_timestamp_t ts)
{
	if (!str) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL output string provided\n",
			  __FUNCTION__);
		return -EINVAL;
	}
	if (!ts) {
		cmyth_dbg(CMYTH_DBG_ERROR, "%s: NULL timestamp provided\n",
			  __FUNCTION__);
		return -EINVAL;
	}
	sprintf(str,
		"%4.4ld-%2.2ld-%2.2ld",
		ts->timestamp_year,
		ts->timestamp_month,
		ts->timestamp_day);
	return 0;
}

MYSQL *
cmyth_db_get_connection(cmyth_database_t db)
{
    if(cmyth_db_check_connection(db) != 0)
    {
       cmyth_dbg(CMYTH_DBG_ERROR, "%s: cmyth_db_check_connection failed\n",
       					__FUNCTION__);
       return NULL;
    }
    return db->mysql;
}

long
cmyth_proginfo_card_id(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: no program info\n", __FUNCTION__);
		return -1;
	}

	return prog->proginfo_card_id;
}

int
cmyth_proginfo_port(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: no program info\n", __FUNCTION__);
		return -1;
	}

	return prog->proginfo_port;
}

/*
 * cmyth_proginfo_host(cmyth_proginfo_t prog)
 *
 * Scope: PUBLIC
 *
 * Description
 *
 * Get the host name of the recorder serving the program 'prog'.
 *
 * Return Value:
 *
 * Success: A held, non-NULL string pointer
 *
 * Failure: NULL
 */
char*
cmyth_proginfo_host(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: no program info\n", __FUNCTION__);
		return NULL;
	}

	return ref_hold(prog->proginfo_host);
}

/*
 * cmyth_proginfo_get_detail(cmyth_conn_t control, cmyth_proginfo_t prog)
 *
 * Scope: PUBLIC
 *
 * Description
 *
 * Completely fill out a program info based on a supplied (possibly
 * incomplete) program info.  The supplied program info will be duplicated and
 * a pointer to the duplicate will be returned.
 *
 * NOTE: The original program info is released before the return.  If the
 *       caller wishes to retain access to the original it must already be
 *       held before the call.  This permits the called to replace a
 *       program info directly with the return from this function.
 *
 * Return Value:
 *
 * Success: A held, Non-NULL program_info
 *
 * Failure: NULL
 */
cmyth_proginfo_t
cmyth_proginfo_get_detail(cmyth_conn_t control, cmyth_proginfo_t p)
{
	cmyth_proginfo_t ret = cmyth_proginfo_dup(p);

	if (ret == NULL) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_proginfo_dup() failed\n",
			  __FUNCTION__);
		return NULL;
	}
	if (cmyth_proginfo_fill(control, ret) < 0) {
		ref_release(ret);
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: cmyth_proginfo_fill() failed\n",
			  __FUNCTION__);
		return NULL;
	}
	return ret;
}

int8_t
cmyth_proginfo_priority(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: no program info\n", __FUNCTION__);
		return 0;
	}

	return prog->proginfo_rec_priority;
}

uint32_t
cmyth_proginfo_recordid(cmyth_proginfo_t prog)
{
	if (!prog) {
		cmyth_dbg(CMYTH_DBG_ERROR,
			  "%s: no program info\n", __FUNCTION__);
		return 0;
	}

	return prog->proginfo_record_id;
}

/*
 * cmyth_rec_num_destroy(cmyth_rec_num_t rn)
 * 
 * Scope: PRIVATE (static)
 *
 * Description
 *
 * Destroy and release all storage associated with the recorder number
 * structure 'rn'.  This function should only ever be called by
 * cmyth_rec_num_release().  All others should call
 * cmyth_rec_num_release() to free rec_num structures.
 *
 * Return Value:
 *
 * None.
 */
static void
cmyth_rec_num_destroy(cmyth_rec_num_t rn)
{
	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	if (!rn) {
		return;
	}
	if (rn->recnum_host) {
		ref_release(rn->recnum_host);
	}
}