void main(void)
{
int ret;
ret = http_client_init(&http_ctx, SERVER_ADDR, SERVER_PORT);
if (ret < 0) {
NET_ERR("HTTP init failed (%d)", ret);
panic(NULL);
}
http_client_set_net_pkt_pool(&http_ctx, tx_slab, data_pool);
ret = do_sync_reqs(&http_ctx, MAX_ITERATIONS);
if (ret < 0) {
goto out;
}
ret = do_async_reqs(&http_ctx, MAX_ITERATIONS);
if (ret < 0) {
goto out;
}
out:
http_client_release(&http_ctx);
NET_INFO("Done!");
}
/* Module functions */
static int
init(G_GNUC_UNUSED const struct mpdcron_config *conf, GKeyFile *fd)
{
/* Parse configuration */
if (file_load(fd) < 0)
return MPDCRON_INIT_FAILURE;
if (http_client_init() < 0)
return MPDCRON_INIT_FAILURE;
as_init(file_config.scrobblers);
timer = g_timer_new();
save_source_id = g_timeout_add_seconds(file_config.journal_interval, timer_save_journal, NULL);
return MPDCRON_INIT_SUCCESS;
}
int32_t elasticsearch_connection_init(const char *url, bool debug,
struct elasticsearch_connection **conn_r,
const char **error_r)
{
struct http_client_settings http_set;
struct elasticsearch_connection *conn = NULL;
struct http_url *http_url = NULL;
const char *error = NULL;
if (error_r == NULL || url == NULL || conn_r == NULL) {
i_debug("fts_elasticsearch: error initialising ElasticSearch connection");
return -1;
} else {
/* safe to continue */
}
/* validate the url */
if (http_url_parse(url, NULL, 0, pool_datastack_create(),
&http_url, &error) < 0) {
*error_r = t_strdup_printf(
"fts_elasticsearch: Failed to parse HTTP url: %s", error);
return -1;
}
conn = i_new(struct elasticsearch_connection, 1);
conn->http_host = i_strdup(http_url->host_name);
conn->http_port = http_url->port;
conn->http_base_url = i_strconcat(http_url->path, http_url->enc_query, NULL);
conn->http_ssl = http_url->have_ssl;
conn->debug = debug;
/* guard against init being called multiple times */
if (elasticsearch_http_client == NULL) {
memset(&http_set, 0, sizeof(http_set));
http_set.max_idle_time_msecs = 5 * 1000;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
http_set.max_redirects = 1;
http_set.max_attempts = 3;
http_set.debug = debug;
elasticsearch_http_client = http_client_init(&http_set);
}
*conn_r = conn;
return 0;
}
int solr_connection_init(const char *url, bool debug,
struct solr_connection **conn_r, const char **error_r)
{
struct http_client_settings http_set;
struct solr_connection *conn;
struct http_url *http_url;
const char *error;
if (http_url_parse(url, NULL, 0, pool_datastack_create(),
&http_url, &error) < 0) {
*error_r = t_strdup_printf(
"fts_solr: Failed to parse HTTP url: %s", error);
return -1;
}
conn = i_new(struct solr_connection, 1);
conn->http_host = i_strdup(http_url->host.name);
conn->http_port = http_url->port;
conn->http_base_url = i_strconcat(http_url->path, http_url->enc_query, NULL);
conn->http_ssl = http_url->have_ssl;
conn->debug = debug;
if (solr_http_client == NULL) {
memset(&http_set, 0, sizeof(http_set));
http_set.max_idle_time_msecs = 5*1000;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
http_set.max_redirects = 1;
http_set.max_attempts = 3;
http_set.debug = debug;
http_set.connect_timeout_msecs = 5*1000;
http_set.request_timeout_msecs = 60*1000;
solr_http_client = http_client_init(&http_set);
}
conn->xml_parser = XML_ParserCreate("UTF-8");
if (conn->xml_parser == NULL) {
i_fatal_status(FATAL_OUTOFMEM,
"fts_solr: Failed to allocate XML parser");
}
*conn_r = conn;
return 0;
}
/**
* \brief Configure HTTP client module.
*/
static void configure_http_client(void)
{
struct http_client_config httpc_conf;
int ret;
http_client_get_config_defaults(&httpc_conf);
httpc_conf.recv_buffer_size = MAIN_BUFFER_MAX_SIZE;
httpc_conf.timer_inst = &swt_module_inst;
ret = http_client_init(&http_client_module_inst, &httpc_conf);
if (ret < 0) {
printf("HTTP client initialization has failed(%s)\r\n", strerror(ret));
while (1) {
} /* Loop forever. */
}
http_client_register_callback(&http_client_module_inst, http_client_callback);
}
static int
tika_get_http_client_url(struct mail_user *user, struct http_url **http_url_r)
{
struct fts_parser_tika_user *tuser = TIKA_USER_CONTEXT(user);
struct http_client_settings http_set;
const char *url, *error;
url = mail_user_plugin_getenv(user, "fts_tika");
if (url == NULL) {
/* fts_tika disabled */
return -1;
}
if (tuser != NULL) {
*http_url_r = tuser->http_url;
return *http_url_r == NULL ? -1 : 0;
}
tuser = p_new(user->pool, struct fts_parser_tika_user, 1);
MODULE_CONTEXT_SET(user, fts_parser_tika_user_module, tuser);
if (http_url_parse(url, NULL, 0, user->pool,
&tuser->http_url, &error) < 0) {
i_error("fts_tika: Failed to parse HTTP url %s: %s", url, error);
return -1;
}
if (tika_http_client == NULL) {
memset(&http_set, 0, sizeof(http_set));
http_set.max_idle_time_msecs = 100;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
http_set.max_redirects = 1;
http_set.max_attempts = 3;
http_set.connect_timeout_msecs = 5*1000;
http_set.request_timeout_msecs = 60*1000;
http_set.debug = user->mail_debug;
tika_http_client = http_client_init(&http_set);
}
*http_url_r = tuser->http_url;
return 0;
}
/*
Send req to IP server and get the response
*/
static RC_TYPE do_ip_server_transaction(DYN_DNS_CLIENT *p_self)
{
RC_TYPE rc = RC_OK;
HTTP_CLIENT *p_http;
p_http = &p_self->http_to_ip_server;
rc = http_client_init(&p_self->http_to_ip_server);
if (rc != RC_OK)
{
return rc;
}
do
{
/*prepare request for IP server*/
{
HTTP_TRANSACTION *p_tr = &p_self->http_tr;
p_tr->req_len = get_req_for_ip_server((DYN_DNS_CLIENT*) p_self,
p_self->info.p_dns_system->p_specific_data);
if (p_self->dbg.level > 2)
{
DBG_PRINTF((LOG_DEBUG, "The request for IP server:\n%s\n",p_self->p_req_buffer));
}
p_tr->p_req = (char*) p_self->p_req_buffer;
p_tr->p_rsp = (char*) p_self->p_work_buffer;
p_tr->max_rsp_len = p_self->work_buffer_size - 1;/*save place for a \0 at the end*/
p_tr->rsp_len = 0;
rc = http_client_transaction(&p_self->http_to_ip_server, &p_self->http_tr);
p_self->p_work_buffer[p_tr->rsp_len] = 0;
}
}
while(0);
/*close*/
http_client_shutdown(&p_self->http_to_ip_server);
return rc;
}
/*
Send req to IP server and get the response
*/
static RC_TYPE do_ip_server_transaction(DYN_DNS_CLIENT *p_self, int servernum)
{
RC_TYPE rc = RC_OK;
HTTP_CLIENT *p_http;
HTTP_TRANSACTION *p_tr;
if (p_self == NULL)
{
return RC_INVALID_POINTER;
}
p_http = &p_self->http_to_ip_server[servernum];
rc = http_client_init(p_http, "Checking for IP# change");
if (rc != RC_OK)
{
return rc;
}
/* Prepare request for IP server */
p_tr = &p_self->http_tr;
p_tr->req_len = get_req_for_ip_server(p_self, servernum);
if (p_self->dbg.level > 2)
{
logit(LOG_DEBUG, MODULE_TAG "Querying DDNS server for my public IP#:");
logit(LOG_DEBUG, MODULE_TAG "%s", p_self->p_req_buffer);
}
p_tr->p_req = (char*) p_self->p_req_buffer;
p_tr->p_rsp = (char*) p_self->p_work_buffer;
p_tr->max_rsp_len = p_self->work_buffer_size - 1; /* Save place for terminating \0 in string. */
p_tr->rsp_len = 0;
rc = http_client_transaction(p_http, &p_self->http_tr);
p_tr->p_rsp[p_tr->rsp_len] = 0;
if (p_tr->status != 200)
rc = RC_DYNDNS_INVALID_RSP_FROM_IP_SERVER;
http_client_shutdown(p_http);
return rc;
}
/**
* \brief Configure HTTP client module.
*/
static void configure_http_client(void)
{
struct http_client_config httpc_conf;
int ret;
http_client_get_config_defaults(&httpc_conf);
httpc_conf.recv_buffer_size = 256;
httpc_conf.timer_inst = &swt_module_inst;
/* ipinfo.io send json format data if only client is a curl. */
httpc_conf.user_agent = "curl/7.10.6";
ret = http_client_init(&http_client_module_inst, &httpc_conf);
if (ret < 0) {
printf("HTTP client initialization has failed(%s)\r\n", strerror(ret));
while (1) {
} /* Loop forever. */
}
http_client_register_callback(&http_client_module_inst, http_client_callback);
}
/*
Send req to IP server and get the response
*/
static int do_ip_server_transaction(ddns_t *ctx, int servernum)
{
int rc = 0;
http_client_t *p_http;
http_trans_t *p_tr;
if (!ctx)
return RC_INVALID_POINTER;
p_http = &ctx->http_to_ip_server[servernum];
rc = http_client_init(p_http, "Checking for IP# change");
if (rc != 0) {
return rc;
}
/* Prepare request for IP server */
p_tr = &ctx->http_transaction;
p_tr->req_len = get_req_for_ip_server(ctx, servernum);
if (ctx->dbg.level > 2) {
logit(LOG_DEBUG, "Querying DDNS server for my public IP#:");
logit(LOG_DEBUG, "%s", ctx->request_buf);
}
p_tr->p_req = (char *)ctx->request_buf;
p_tr->p_rsp = (char *)ctx->work_buf;
p_tr->max_rsp_len = ctx->work_buflen - 1; /* Save place for terminating \0 in string. */
p_tr->rsp_len = 0;
rc = http_client_transaction(p_http, &ctx->http_transaction);
p_tr->p_rsp[p_tr->rsp_len] = 0;
if (p_tr->status != 200)
rc = RC_DYNDNS_INVALID_RSP_FROM_IP_SERVER;
http_client_shutdown(p_http);
return rc;
}
/**
* \brief Configure HTTP client module.
*/
static bool _thethingsio_example_configure_http_client(thethingsio_http_cb cb)
{
struct http_client_config httpc_conf;
int ret;
http_client_get_config_defaults(&httpc_conf);
// httpc_conf.recv_buffer_size = 256;
httpc_conf.recv_buffer_size = 512;
httpc_conf.send_buffer_size = 1024;
httpc_conf.timer_inst = &swt_module_inst;
/* ipinfo.io send json format data if only client is a curl. */
httpc_conf.user_agent = "curl/7.10.6";
ret = http_client_init(&http_client_module_inst, &httpc_conf);
if (ret < 0) {
DEBUG(DEBUG_CONF_THETHINGSIO"HTTP client initialization has failed(%s)"DEBUG_EOL, strerror(ret));
return false;
}
http_client_register_callback(&http_client_module_inst, cb);
return true;
}
int http_client_demo(void)
{
int idle_count = 0,command;
rtp_net_init();
rtp_threads_init();
while ((command = prompt_for_command()) != COMMAND_QUIT)
{
HTTPManagedClient httpClient;
if (http_client_init(&httpClient) < 0)
return(-1);
if (command == COMMAND_GET)
http_client_get(&httpClient,0);
else if (command == COMMAND_GETTO_FILE)
http_client_get(&httpClient,1);
else if (command == COMMAND_POST)
http_client_post(&httpClient);
else if (command == COMMAND_PUT)
http_client_put(&httpClient);
}
rtp_net_exit();
return (0);
}
int
main(int argc, char **argv)
{
int i;
sigset_t set;
#if ENABLE_MPEGTS
uint32_t adapter_mask = 0;
#endif
int log_level = LOG_INFO;
int log_options = TVHLOG_OPT_MILLIS | TVHLOG_OPT_STDERR | TVHLOG_OPT_SYSLOG;
const char *log_debug = NULL, *log_trace = NULL;
gid_t gid = -1;
uid_t uid = -1;
char buf[512];
FILE *pidfile = NULL;
extern int dvb_bouquets_parse;
main_tid = pthread_self();
/* Setup global mutexes */
pthread_mutex_init(&fork_lock, NULL);
pthread_mutex_init(&global_lock, NULL);
pthread_mutex_init(&tasklet_lock, NULL);
pthread_mutex_init(&atomic_lock, NULL);
pthread_cond_init(>imer_cond, NULL);
pthread_cond_init(&tasklet_cond, NULL);
TAILQ_INIT(&tasklets);
/* Defaults */
tvheadend_webui_port = 9981;
tvheadend_webroot = NULL;
tvheadend_htsp_port = 9982;
tvheadend_htsp_port_extra = 0;
time(&dispatch_clock);
/* Command line options */
int opt_help = 0,
opt_version = 0,
opt_fork = 0,
opt_firstrun = 0,
opt_stderr = 0,
opt_syslog = 0,
opt_nosyslog = 0,
opt_uidebug = 0,
opt_abort = 0,
opt_noacl = 0,
opt_fileline = 0,
opt_threadid = 0,
opt_libav = 0,
opt_ipv6 = 0,
opt_satip_rtsp = 0,
#if ENABLE_TSFILE
opt_tsfile_tuner = 0,
#endif
opt_dump = 0,
opt_xspf = 0,
opt_dbus = 0,
opt_dbus_session = 0,
opt_nobackup = 0,
opt_nobat = 0;
const char *opt_config = NULL,
*opt_user = NULL,
*opt_group = NULL,
*opt_logpath = NULL,
*opt_log_debug = NULL,
*opt_log_trace = NULL,
*opt_pidpath = "/var/run/tvheadend.pid",
#if ENABLE_LINUXDVB
*opt_dvb_adapters = NULL,
#endif
*opt_bindaddr = NULL,
*opt_subscribe = NULL,
*opt_user_agent = NULL;
str_list_t opt_satip_xml = { .max = 10, .num = 0, .str = calloc(10, sizeof(char*)) };
str_list_t opt_tsfile = { .max = 10, .num = 0, .str = calloc(10, sizeof(char*)) };
cmdline_opt_t cmdline_opts[] = {
{ 0, NULL, N_("Generic Options"), OPT_BOOL, NULL },
{ 'h', "help", N_("Show this page"), OPT_BOOL, &opt_help },
{ 'v', "version", N_("Show version information"),OPT_BOOL, &opt_version },
{ 0, NULL, N_("Service Configuration"), OPT_BOOL, NULL },
{ 'c', "config", N_("Alternate config path"), OPT_STR, &opt_config },
{ 'B', "nobackup", N_("Don't backup config tree at upgrade"), OPT_BOOL, &opt_nobackup },
{ 'f', "fork", N_("Fork and run as daemon"), OPT_BOOL, &opt_fork },
{ 'u', "user", N_("Run as user"), OPT_STR, &opt_user },
{ 'g', "group", N_("Run as group"), OPT_STR, &opt_group },
{ 'p', "pid", N_("Alternate pid path"), OPT_STR, &opt_pidpath },
{ 'C', "firstrun", N_("If no user account exists then create one with\n"
"no username and no password. Use with care as\n"
"it will allow world-wide administrative access\n"
"to your Tvheadend installation until you edit/create\n"
"access-control from within the Tvheadend UI"),
OPT_BOOL, &opt_firstrun },
#if ENABLE_DBUS_1
{ 'U', "dbus", N_("Enable DBus"),
OPT_BOOL, &opt_dbus },
{ 'e', "dbus_session", N_("DBus - use the session message bus instead system one"),
OPT_BOOL, &opt_dbus_session },
#endif
#if ENABLE_LINUXDVB
{ 'a', "adapters", N_("Only use specified DVB adapters (comma separated)"),
OPT_STR, &opt_dvb_adapters },
#endif
#if ENABLE_SATIP_SERVER
{ 0, "satip_rtsp", N_("SAT>IP RTSP port number for server\n"
"(default: -1 = disable, 0 = webconfig, standard port is 554)"),
OPT_INT, &opt_satip_rtsp },
#endif
#if ENABLE_SATIP_CLIENT
{ 0, "satip_xml", N_("URL with the SAT>IP server XML location"),
OPT_STR_LIST, &opt_satip_xml },
#endif
{ 0, NULL, N_("Server Connectivity"), OPT_BOOL, NULL },
{ '6', "ipv6", N_("Listen on IPv6"), OPT_BOOL, &opt_ipv6 },
{ 'b', "bindaddr", N_("Specify bind address"), OPT_STR, &opt_bindaddr},
{ 0, "http_port", N_("Specify alternative http port"),
OPT_INT, &tvheadend_webui_port },
{ 0, "http_root", N_("Specify alternative http webroot"),
OPT_STR, &tvheadend_webroot },
{ 0, "htsp_port", N_("Specify alternative htsp port"),
OPT_INT, &tvheadend_htsp_port },
{ 0, "htsp_port2", N_("Specify extra htsp port"),
OPT_INT, &tvheadend_htsp_port_extra },
{ 0, "useragent", N_("Specify User-Agent header for the http client"),
OPT_STR, &opt_user_agent },
{ 0, "xspf", N_("Use XSPF playlist instead of M3U"),
OPT_BOOL, &opt_xspf },
{ 0, NULL, N_("Debug Options"), OPT_BOOL, NULL },
{ 'd', "stderr", N_("Enable debug on stderr"), OPT_BOOL, &opt_stderr },
{ 's', "syslog", N_("Enable debug to syslog"), OPT_BOOL, &opt_syslog },
{ 'S', "nosyslog", N_("Disable syslog (all msgs)"), OPT_BOOL, &opt_nosyslog },
{ 'l', "logfile", N_("Enable debug to file"), OPT_STR, &opt_logpath },
{ 0, "debug", N_("Enable debug subsystems"), OPT_STR, &opt_log_debug },
#if ENABLE_TRACE
{ 0, "trace", N_("Enable trace subsystems"), OPT_STR, &opt_log_trace },
#endif
{ 0, "fileline", N_("Add file and line numbers to debug"), OPT_BOOL, &opt_fileline },
{ 0, "threadid", N_("Add the thread ID to debug"), OPT_BOOL, &opt_threadid },
#if ENABLE_LIBAV
{ 0, "libav", N_("More verbose libav log"), OPT_BOOL, &opt_libav },
#endif
{ 0, "uidebug", N_("Enable webUI debug (non-minified JS)"), OPT_BOOL, &opt_uidebug },
{ 'A', "abort", N_("Immediately abort"), OPT_BOOL, &opt_abort },
{ 'D', "dump", N_("Enable coredumps for daemon"), OPT_BOOL, &opt_dump },
{ 0, "noacl", N_("Disable all access control checks"),
OPT_BOOL, &opt_noacl },
{ 0, "nobat", N_("Disable DVB bouquets"),
OPT_BOOL, &opt_nobat },
{ 'j', "join", N_("Subscribe to a service permanently"),
OPT_STR, &opt_subscribe },
#if ENABLE_TSFILE || ENABLE_TSDEBUG
{ 0, NULL, N_("Testing options"), OPT_BOOL, NULL },
{ 0, "tsfile_tuners", N_("Number of tsfile tuners"), OPT_INT, &opt_tsfile_tuner },
{ 0, "tsfile", N_("tsfile input (mux file)"), OPT_STR_LIST, &opt_tsfile },
#endif
#if ENABLE_TSDEBUG
{ 0, "tsdebug", N_("Output directory for tsdebug"), OPT_STR, &tvheadend_tsdebug },
#endif
};
/* Get current directory */
tvheadend_cwd0 = dirname(tvh_strdupa(argv[0]));
tvheadend_cwd = dirname(tvh_strdupa(tvheadend_cwd0));
/* Set locale */
setlocale(LC_ALL, "");
setlocale(LC_NUMERIC, "C");
/* make sure the timezone is set */
tzset();
/* Process command line */
for (i = 1; i < argc; i++) {
/* Find option */
cmdline_opt_t *opt
= cmdline_opt_find(cmdline_opts, ARRAY_SIZE(cmdline_opts), argv[i]);
if (!opt)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts),
_("invalid option specified [%s]"), argv[i]);
/* Process */
if (opt->type == OPT_BOOL)
*((int*)opt->param) = 1;
else if (++i == argc)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts),
_("option %s requires a value"), opt->lopt);
else if (opt->type == OPT_INT)
*((int*)opt->param) = atoi(argv[i]);
else if (opt->type == OPT_STR_LIST) {
str_list_t *strl = opt->param;
if (strl->num < strl->max)
strl->str[strl->num++] = argv[i];
}
else
*((char**)opt->param) = argv[i];
/* Stop processing */
if (opt_help)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts), NULL);
if (opt_version)
show_version(argv[0]);
}
/* Additional cmdline processing */
if (opt_nobat)
dvb_bouquets_parse = 0;
#if ENABLE_LINUXDVB
if (!opt_dvb_adapters) {
adapter_mask = ~0;
} else {
char *p, *e;
char *r = NULL;
char *dvb_adapters = strdup(opt_dvb_adapters);
adapter_mask = 0x0;
p = strtok_r(dvb_adapters, ",", &r);
while (p) {
int a = strtol(p, &e, 10);
if (*e != 0 || a < 0 || a > 31) {
fprintf(stderr, _("Invalid adapter number '%s'\n"), p);
free(dvb_adapters);
return 1;
}
adapter_mask |= (1 << a);
p = strtok_r(NULL, ",", &r);
}
free(dvb_adapters);
if (!adapter_mask) {
fprintf(stderr, "%s", _("No adapters specified!\n"));
return 1;
}
}
#endif
if (tvheadend_webroot) {
char *tmp;
if (*tvheadend_webroot == '/')
tmp = strdup(tvheadend_webroot);
else {
tmp = malloc(strlen(tvheadend_webroot)+2);
*tmp = '/';
strcpy(tmp+1, tvheadend_webroot);
}
if (tmp[strlen(tmp)-1] == '/')
tmp[strlen(tmp)-1] = '\0';
tvheadend_webroot = tmp;
}
tvheadend_webui_debug = opt_uidebug;
/* Setup logging */
if (isatty(2))
log_options |= TVHLOG_OPT_DECORATE;
if (opt_stderr || opt_syslog || opt_logpath) {
if (!opt_log_trace && !opt_log_debug)
log_debug = "all";
log_level = LOG_DEBUG;
if (opt_stderr)
log_options |= TVHLOG_OPT_DBG_STDERR;
if (opt_syslog)
log_options |= TVHLOG_OPT_DBG_SYSLOG;
if (opt_logpath)
log_options |= TVHLOG_OPT_DBG_FILE;
}
if (opt_nosyslog)
log_options &= ~(TVHLOG_OPT_SYSLOG|TVHLOG_OPT_DBG_SYSLOG);
if (opt_fileline)
log_options |= TVHLOG_OPT_FILELINE;
if (opt_threadid)
log_options |= TVHLOG_OPT_THREAD;
if (opt_libav)
log_options |= TVHLOG_OPT_LIBAV;
if (opt_log_trace) {
log_level = LOG_TRACE;
log_trace = opt_log_trace;
}
if (opt_log_debug)
log_debug = opt_log_debug;
tvhlog_init(log_level, log_options, opt_logpath);
tvhlog_set_debug(log_debug);
tvhlog_set_trace(log_trace);
tvhinfo("main", "Log started");
signal(SIGPIPE, handle_sigpipe); // will be redundant later
signal(SIGILL, handle_sigill); // see handler..
/* Set priviledges */
if(opt_fork || opt_group || opt_user) {
const char *homedir;
struct group *grp = getgrnam(opt_group ?: "video");
struct passwd *pw = opt_user ? getpwnam(opt_user) : NULL;
if(grp != NULL) {
gid = grp->gr_gid;
} else {
gid = 1;
}
if (pw != NULL) {
if (getuid() != pw->pw_uid) {
gid_t glist[16];
int gnum;
gnum = get_user_groups(pw, glist, ARRAY_SIZE(glist));
if (gnum > 0 && setgroups(gnum, glist)) {
char buf[256] = "";
int i;
for (i = 0; i < gnum; i++)
snprintf(buf + strlen(buf), sizeof(buf) - 1 - strlen(buf),
",%d", glist[i]);
tvhlog(LOG_ALERT, "START",
"setgroups(%s) failed, do you have permission?", buf+1);
return 1;
}
}
uid = pw->pw_uid;
homedir = pw->pw_dir;
setenv("HOME", homedir, 1);
} else {
uid = 1;
}
}
uuid_init();
config_boot(opt_config, gid, uid);
tcp_server_preinit(opt_ipv6);
http_server_init(opt_bindaddr); // bind to ports only
htsp_init(opt_bindaddr); // bind to ports only
satip_server_init(opt_satip_rtsp); // bind to ports only
if (opt_fork)
pidfile = tvh_fopen(opt_pidpath, "w+");
if (gid != -1 && (getgid() != gid) && setgid(gid)) {
tvhlog(LOG_ALERT, "START",
"setgid(%d) failed, do you have permission?", gid);
return 1;
}
if (uid != -1 && (getuid() != uid) && setuid(uid)) {
tvhlog(LOG_ALERT, "START",
"setuid(%d) failed, do you have permission?", uid);
return 1;
}
/* Daemonise */
if(opt_fork) {
if(daemon(0, 0)) {
exit(2);
}
if(pidfile != NULL) {
fprintf(pidfile, "%d\n", getpid());
fclose(pidfile);
}
/* Make dumpable */
if (opt_dump) {
#ifdef PLATFORM_LINUX
if (chdir("/tmp"))
tvhwarn("START", "failed to change cwd to /tmp");
prctl(PR_SET_DUMPABLE, 1);
#else
tvhwarn("START", "Coredumps not implemented on your platform");
#endif
}
umask(0);
}
tvheadend_running = 1;
/* Start log thread (must be done post fork) */
tvhlog_start();
/* Alter logging */
if (opt_fork)
tvhlog_options &= ~TVHLOG_OPT_STDERR;
if (!isatty(2))
tvhlog_options &= ~TVHLOG_OPT_DECORATE;
/* Initialise clock */
pthread_mutex_lock(&global_lock);
time(&dispatch_clock);
/* Signal handling */
sigfillset(&set);
sigprocmask(SIG_BLOCK, &set, NULL);
trap_init(argv[0]);
/* SSL library init */
OPENSSL_config(NULL);
SSL_load_error_strings();
SSL_library_init();
/* Initialise configuration */
notify_init();
idnode_init();
spawn_init();
config_init(opt_nobackup == 0);
/**
* Initialize subsystems
*/
epg_in_load = 1;
tvhthread_create(&tasklet_tid, NULL, tasklet_thread, NULL);
dbus_server_init(opt_dbus, opt_dbus_session);
intlconv_init();
api_init();
fsmonitor_init();
libav_init();
tvhtime_init();
profile_init();
imagecache_init();
http_client_init(opt_user_agent);
esfilter_init();
bouquet_init();
service_init();
dvb_init();
#if ENABLE_MPEGTS
mpegts_init(adapter_mask, &opt_satip_xml, &opt_tsfile, opt_tsfile_tuner);
#endif
channel_init();
bouquet_service_resolve();
subscription_init();
dvr_config_init();
access_init(opt_firstrun, opt_noacl);
#if ENABLE_TIMESHIFT
timeshift_init();
#endif
tcp_server_init();
webui_init(opt_xspf);
#if ENABLE_UPNP
upnp_server_init(opt_bindaddr);
#endif
service_mapper_init();
descrambler_init();
epggrab_init();
epg_init();
dvr_init();
dbus_server_start();
http_server_register();
satip_server_register();
htsp_register();
if(opt_subscribe != NULL)
subscription_dummy_join(opt_subscribe, 1);
avahi_init();
bonjour_init();
epg_updated(); // cleanup now all prev ref's should have been created
epg_in_load = 0;
pthread_mutex_unlock(&global_lock);
/**
* Wait for SIGTERM / SIGINT, but only in this thread
*/
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
signal(SIGTERM, doexit);
signal(SIGINT, doexit);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
tvhlog(LOG_NOTICE, "START", "HTS Tvheadend version %s started, "
"running as PID:%d UID:%d GID:%d, CWD:%s CNF:%s",
tvheadend_version,
getpid(), getuid(), getgid(), getcwd(buf, sizeof(buf)),
hts_settings_get_root());
if(opt_abort)
abort();
mainloop();
#if ENABLE_DBUS_1
tvhftrace("main", dbus_server_done);
#endif
#if ENABLE_UPNP
tvhftrace("main", upnp_server_done);
#endif
tvhftrace("main", satip_server_done);
tvhftrace("main", htsp_done);
tvhftrace("main", http_server_done);
tvhftrace("main", webui_done);
tvhftrace("main", fsmonitor_done);
tvhftrace("main", http_client_done);
tvhftrace("main", tcp_server_done);
// Note: the locking is obviously a bit redundant, but without
// we need to disable the gtimer_arm call in epg_save()
pthread_mutex_lock(&global_lock);
tvhftrace("main", epg_save);
#if ENABLE_TIMESHIFT
tvhftrace("main", timeshift_term);
#endif
pthread_mutex_unlock(&global_lock);
tvhftrace("main", epggrab_done);
#if ENABLE_MPEGTS
tvhftrace("main", mpegts_done);
#endif
tvhftrace("main", descrambler_done);
tvhftrace("main", service_mapper_done);
tvhftrace("main", service_done);
tvhftrace("main", channel_done);
tvhftrace("main", bouquet_done);
tvhftrace("main", dvr_done);
tvhftrace("main", subscription_done);
tvhftrace("main", access_done);
tvhftrace("main", epg_done);
tvhftrace("main", avahi_done);
tvhftrace("main", bonjour_done);
tvhftrace("main", imagecache_done);
tvhftrace("main", lang_code_done);
tvhftrace("main", api_done);
tvhtrace("main", "tasklet enter");
pthread_cond_signal(&tasklet_cond);
pthread_join(tasklet_tid, NULL);
tvhtrace("main", "tasklet thread end");
tasklet_flush();
tvhtrace("main", "tasklet leave");
tvhftrace("main", hts_settings_done);
tvhftrace("main", dvb_done);
tvhftrace("main", lang_str_done);
tvhftrace("main", esfilter_done);
tvhftrace("main", profile_done);
tvhftrace("main", intlconv_done);
tvhftrace("main", urlparse_done);
tvhftrace("main", idnode_done);
tvhftrace("main", notify_done);
tvhftrace("main", spawn_done);
tvhlog(LOG_NOTICE, "STOP", "Exiting HTS Tvheadend");
tvhlog_end();
tvhftrace("main", config_done);
if(opt_fork)
unlink(opt_pidpath);
#if ENABLE_TSFILE
free(opt_tsfile.str);
#endif
free(opt_satip_xml.str);
/* OpenSSL - welcome to the "cleanup" hell */
ENGINE_cleanup();
RAND_cleanup();
CRYPTO_cleanup_all_ex_data();
EVP_cleanup();
CONF_modules_free();
#ifndef OPENSSL_NO_COMP
COMP_zlib_cleanup();
#endif
ERR_remove_state(0);
ERR_free_strings();
#ifndef OPENSSL_NO_COMP
sk_SSL_COMP_free(SSL_COMP_get_compression_methods());
#endif
/* end of OpenSSL cleanup code */
#if ENABLE_DBUS_1
extern void dbus_shutdown(void);
if (opt_dbus) dbus_shutdown();
#endif
return 0;
}
/**
*
*/
void
tvh_str_set(char **strp, const char *src)
{
free(*strp);
*strp = src ? strdup(src) : NULL;
}
/**
*
*/
int
tvh_str_update(char **strp, const char *src)
{
if(src == NULL)
return 0;
free(*strp);
*strp = strdup(src);
return 1;
}
/**
*
*/
void
scopedunlock(pthread_mutex_t **mtxp)
{
pthread_mutex_unlock(*mtxp);
}
static int get_req_for_freedns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt)
{
RC_TYPE rc = RC_OK, rc2;
HTTP_CLIENT http_to_dyndns;
HTTP_TRANSACTION http_tr;
char buffer[256];
unsigned char digestbuf[SHA1_DIGEST_BYTES];
char digeststr[SHA1_DIGEST_BYTES*2+1];
int i;
char *buf, *tmp, *line;
char host[256], updateurl[256];
char *hash = NULL;
if (p_self == NULL)
{
/* 0 == "No characters written" */
return 0;
}
// I know it's ugly, http client needs redesign.
do
{
if ((rc = http_client_construct(&http_to_dyndns)) != RC_OK)
break;
http_client_set_port(&http_to_dyndns, p_self->info[infcnt].dyndns_server_name.port);
http_client_set_remote_name(&http_to_dyndns, p_self->info[infcnt].dyndns_server_name.name);
http_client_set_bind_iface(&http_to_dyndns, p_self->bind_interface);
if ((rc = http_client_init(&http_to_dyndns, "Sending update URL query")) != RC_OK)
break;
snprintf(buffer, sizeof(buffer), "%s|%s",
p_self->info[infcnt].credentials.my_username,
p_self->info[infcnt].credentials.my_password);
sha1(buffer, strlen(buffer), digestbuf);
for (i = 0; i < SHA1_DIGEST_BYTES; i++)
sprintf(&digeststr[i*2], "%02x", digestbuf[i]);
snprintf(buffer, sizeof(buffer), "/api/?action=getdyndns&sha=%s", digeststr);
http_tr.req_len = sprintf(p_self->p_req_buffer, GENERIC_HTTP_REQUEST,
buffer, p_self->info[infcnt].dyndns_server_name.name);
http_tr.p_req = (char*) p_self->p_req_buffer;
http_tr.p_rsp = (char*) p_self->p_work_buffer;
http_tr.max_rsp_len = p_self->work_buffer_size - 1; /* Save place for a \0 at the end */
http_tr.rsp_len = 0;
rc = http_client_transaction(&http_to_dyndns, &http_tr);
http_tr.p_rsp[http_tr.rsp_len] = 0;
rc2 = http_client_shutdown(&http_to_dyndns);
http_client_destruct(&http_to_dyndns, 1);
if (rc != RC_OK || rc2 != RC_OK)
break;
if ((rc = is_http_status_code_ok(http_tr.status)) != RC_OK)
break;
tmp = buf = strdup(http_tr.p_rsp_body);
for (line = strsep(&tmp, "\n"); line; line = strsep(&tmp, "\n")) {
if (*line &&
sscanf(line, "%255[^|\r\n]|%*[^|\r\n]|%255[^|\r\n]", host, updateurl) == 2 &&
!strcmp(host, p_self->info[infcnt].alias_info[alcnt].names.name)) {
hash = strstr(updateurl, "?");
break;
}
}
free(buf);
if (!hash)
rc = RC_DYNDNS_RSP_NOTOK;
}
while (0);
if (rc != RC_OK)
{
logit(LOG_INFO, MODULE_TAG "Update URL query failed");
return 0;
}
return sprintf(p_self->p_req_buffer, FREEDNS_UPDATE_IP_REQUEST,
p_self->info[infcnt].dyndns_server_url,
hash,
p_self->info[infcnt].my_ip_address.name,
p_self->info[infcnt].dyndns_server_name.name);
}
static RC_TYPE do_update_alias_table(DYN_DNS_CLIENT *p_self)
{
int i, j;
RC_TYPE rc = RC_OK, rc2;
HTTP_TRANSACTION http_tr;
int anychange = 0;
for (i = 0; i < p_self->info_count; i++)
{
DYNDNS_INFO_TYPE *info = &p_self->info[i];
for (j = 0; j < info->alias_count; j++)
{
if (info->alias_info[j].update_required != TRUE)
{
continue;
}
rc = http_client_init(&p_self->http_to_dyndns[i], "Sending IP# update to DDNS server");
if (rc != RC_OK)
{
break;
}
/* Build dyndns transaction */
http_tr.req_len = info->p_dns_system->p_dns_update_req_func(
(struct _DYN_DNS_CLIENT*) p_self, i, j);
http_tr.p_req = (char*) p_self->p_req_buffer;
http_tr.p_rsp = (char*) p_self->p_work_buffer;
http_tr.max_rsp_len = p_self->work_buffer_size - 1; /* Save place for a \0 at the end */
http_tr.rsp_len = 0;
rc = http_client_transaction(&p_self->http_to_dyndns[i], &http_tr);
http_tr.p_rsp[http_tr.rsp_len] = 0;
if (p_self->dbg.level > 2)
{
p_self->p_req_buffer[http_tr.req_len] = 0;
logit(LOG_DEBUG, MODULE_TAG "Sending alias table update to DDNS server:");
logit(LOG_DEBUG, MODULE_TAG "%s", p_self->p_req_buffer);
}
if (rc == RC_OK)
{
rc = info->p_dns_system->p_rsp_ok_func((struct _DYN_DNS_CLIENT*)p_self,
&http_tr, i);
if (rc == RC_OK)
{
info->alias_info[j].update_required = FALSE;
logit(LOG_INFO, MODULE_TAG "Successful alias table update for %s => new IP# %s",
info->alias_info[j].names.name, info->my_ip_address.name);
p_self->time_since_last_update = 0;
anychange++; /* Adjust forced update period on success */
}
else
{
logit(LOG_WARNING, MODULE_TAG "%s error in DDNS server response:",
rc == RC_DYNDNS_RSP_RETRY_LATER ? "Temporary" : "Fatal");
logit(LOG_WARNING, MODULE_TAG "[%d %s] %s",
http_tr.status, http_tr.status_desc,
http_tr.p_rsp_body != http_tr.p_rsp ? http_tr.p_rsp_body : "");
}
if (p_self->dbg.level > 2)
{
logit(LOG_DEBUG, MODULE_TAG "DDNS server response:");
logit(LOG_DEBUG, MODULE_TAG "%s", http_tr.p_rsp);
}
}
rc2 = http_client_shutdown(&p_self->http_to_dyndns[i]);
if (rc == RC_OK)
{
/* Only overwrite rc with of http_client_shutdown() rc if previous call, in
* e.g., http_client_transaction() or the p_rsp_ok_func() callback was OK. */
rc = rc2;
}
if (rc != RC_OK)
{
break;
}
os_sleep_ms(1000);
}
}
/* Successful change or when cache file does not yet exist! */
if (anychange || access(p_self->cachefile, F_OK))
{
FILE *fp;
/* Update cache with new IP */
fp = fopen(p_self->cachefile, "w");
if (fp)
{
fprintf(fp, "%s", p_self->info[0].my_ip_address.name);
fclose(fp);
}
if (anychange && p_self->external_command)
{
/* Run external command hook on update. */
os_shell_execute(p_self->external_command);
}
}
return rc;
}
int8_t
http_send_message(char *msg_out, char **msg_in)
{
CURLcode res;
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, msg_out);
http_c.header_list = NULL;
http_c.header_list = curl_slist_append(http_c.header_list, "Accept:");
if (!http_c.header_list) return -1;
http_c.header_list = curl_slist_append(http_c.header_list, "User-Agent: easycwmp");
if (!http_c.header_list) return -1;
http_c.header_list = curl_slist_append(http_c.header_list, "Content-Type: text/xml; charset=\"utf-8\"");
if (!http_c.header_list) return -1;
if (config->acs->http100continue_disable) {
http_c.header_list = curl_slist_append(http_c.header_list, "Expect:");
if (!http_c.header_list) return -1;
}
if (msg_out) {
DDF("+++ SEND HTTP REQUEST +++\n");
DDF("%s", msg_out);
DDF("--- SEND HTTP REQUEST ---\n");
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long) strlen(msg_out));
http_c.header_list = curl_slist_append(http_c.header_list, "SOAPAction;");
if (!http_c.header_list) return -1;
}
else {
DDF("+++ SEND EMPTY HTTP REQUEST +++\n");
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
}
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_c.header_list);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, msg_in);
*msg_in = (char *) calloc (1, sizeof(char));
res = curl_easy_perform(curl);
if (http_c.header_list) {
curl_slist_free_all(http_c.header_list);
http_c.header_list = NULL;
}
if (!strlen(*msg_in)) {
FREE(*msg_in);
}
long httpCode = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
if (httpCode == 302 || httpCode == 307) {
curl_easy_getinfo(curl, CURLINFO_REDIRECT_URL, &http_redirect_url);
if ((http_redirect_url = strdup(http_redirect_url)) == NULL)
return -1;
http_client_exit();
if (http_client_init()) {
D("receiving http redirect: re-initializing http client failed\n");
FREE(http_redirect_url);
return -1;
}
FREE(http_redirect_url);
FREE(*msg_in);
int redirect = http_send_message(msg_out, msg_in);
return redirect;
}
if (res || (httpCode != 200 && httpCode != 204)) {
log_message(NAME, L_NOTICE, "sending http message failed\n");
return -1;
}
if (*msg_in) {
DDF("+++ RECEIVED HTTP RESPONSE +++\n");
DDF("%s", *msg_in);
DDF("--- RECEIVED HTTP RESPONSE ---\n");
} else {
DDF("+++ RECEIVED EMPTY HTTP RESPONSE +++\n");
}
return 0;
}
static int get_req_for_freedns_server(ddns_t *ctx, int infcnt, int alcnt)
{
int rc = 0, rc2;
http_client_t client;
http_trans_t trans;
char buffer[256];
unsigned char digestbuf[SHA1_DIGEST_BYTES];
char digeststr[SHA1_DIGEST_BYTES * 2 + 1];
int i;
char *buf, *tmp, *line;
char host[256], updateurl[256];
char *hash = NULL;
if (ctx == NULL) {
/* 0 == "No characters written" */
return 0;
}
// I know it's ugly, http client needs redesign.
do {
if ((rc = http_client_construct(&client)) != 0)
break;
http_client_set_port(&client, ctx->info[infcnt].dyndns_server_name.port);
http_client_set_remote_name(&client, ctx->info[infcnt].dyndns_server_name.name);
http_client_set_bind_iface(&client, ctx->bind_interface);
if ((rc = http_client_init(&client, "Sending update URL query")) != 0)
break;
snprintf(buffer, sizeof(buffer), "%s|%s",
ctx->info[infcnt].creds.username, ctx->info[infcnt].creds.password);
sha1((unsigned char *)buffer, strlen(buffer), digestbuf);
for (i = 0; i < SHA1_DIGEST_BYTES; i++)
sprintf(&digeststr[i * 2], "%02x", digestbuf[i]);
snprintf(buffer, sizeof(buffer), "/api/?action=getdyndns&sha=%s", digeststr);
trans.req_len = sprintf(ctx->request_buf, GENERIC_HTTP_REQUEST,
buffer, ctx->info[infcnt].dyndns_server_name.name);
trans.p_req = (char *)ctx->request_buf;
trans.p_rsp = (char *)ctx->work_buf;
trans.max_rsp_len = ctx->work_buflen - 1; /* Save place for a \0 at the end */
trans.rsp_len = 0;
rc = http_client_transaction(&client, &trans);
trans.p_rsp[trans.rsp_len] = 0;
rc2 = http_client_shutdown(&client);
http_client_destruct(&client, 1);
if (rc != 0 || rc2 != 0)
break;
if ((rc = is_http_status_code_ok(trans.status)) != 0)
break;
tmp = buf = strdup(trans.p_rsp_body);
for (line = strsep(&tmp, "\n"); line; line = strsep(&tmp, "\n")) {
if (*line &&
sscanf(line, "%255[^|\r\n]|%*[^|\r\n]|%255[^|\r\n]",
host, updateurl) == 2
&& !strcmp(host, ctx->info[infcnt].alias[alcnt].names.name)) {
hash = strstr(updateurl, "?");
break;
}
}
free(buf);
if (!hash)
rc = RC_DYNDNS_RSP_NOTOK;
}
while (0);
if (rc != 0) {
logit(LOG_INFO, "Update URL query failed");
return 0;
}
return sprintf(ctx->request_buf, FREEDNS_UPDATE_IP_REQUEST,
ctx->info[infcnt].dyndns_server_url,
hash, ctx->info[infcnt].my_ip_address.name, ctx->info[infcnt].dyndns_server_name.name);
}
int
main(int argc, char **argv)
{
int i;
sigset_t set;
#if ENABLE_LINUXDVB
uint32_t adapter_mask;
#endif
int log_level = LOG_INFO;
int log_options = TVHLOG_OPT_MILLIS | TVHLOG_OPT_STDERR | TVHLOG_OPT_SYSLOG;
const char *log_debug = NULL, *log_trace = NULL;
char buf[512];
main_tid = pthread_self();
/* Setup global mutexes */
pthread_mutex_init(&ffmpeg_lock, NULL);
pthread_mutex_init(&fork_lock, NULL);
pthread_mutex_init(&global_lock, NULL);
pthread_mutex_init(&atomic_lock, NULL);
pthread_cond_init(>imer_cond, NULL);
/* Defaults */
tvheadend_webui_port = 9981;
tvheadend_webroot = NULL;
tvheadend_htsp_port = 9982;
tvheadend_htsp_port_extra = 0;
/* Command line options */
int opt_help = 0,
opt_version = 0,
opt_fork = 0,
opt_firstrun = 0,
opt_stderr = 0,
opt_syslog = 0,
opt_uidebug = 0,
opt_abort = 0,
opt_noacl = 0,
opt_fileline = 0,
opt_threadid = 0,
opt_ipv6 = 0,
opt_tsfile_tuner = 0,
opt_dump = 0;
const char *opt_config = NULL,
*opt_user = NULL,
*opt_group = NULL,
*opt_logpath = NULL,
*opt_log_debug = NULL,
*opt_log_trace = NULL,
*opt_pidpath = "/var/run/tvheadend.pid",
#if ENABLE_LINUXDVB
*opt_dvb_adapters = NULL,
#endif
*opt_bindaddr = NULL,
*opt_subscribe = NULL;
str_list_t opt_tsfile = { .max = 10, .num = 0, .str = calloc(10, sizeof(char*)) };
cmdline_opt_t cmdline_opts[] = {
{ 0, NULL, "Generic Options", OPT_BOOL, NULL },
{ 'h', "help", "Show this page", OPT_BOOL, &opt_help },
{ 'v', "version", "Show version infomation", OPT_BOOL, &opt_version },
{ 0, NULL, "Service Configuration", OPT_BOOL, NULL },
{ 'c', "config", "Alternate config path", OPT_STR, &opt_config },
{ 'f', "fork", "Fork and run as daemon", OPT_BOOL, &opt_fork },
{ 'u', "user", "Run as user", OPT_STR, &opt_user },
{ 'g', "group", "Run as group", OPT_STR, &opt_group },
{ 'p', "pid", "Alternate pid path", OPT_STR, &opt_pidpath },
{ 'C', "firstrun", "If no user account exists then create one with\n"
"no username and no password. Use with care as\n"
"it will allow world-wide administrative access\n"
"to your Tvheadend installation until you edit\n"
"the access-control from within the Tvheadend UI",
OPT_BOOL, &opt_firstrun },
#if ENABLE_LINUXDVB
{ 'a', "adapters", "Only use specified DVB adapters (comma separated)",
OPT_STR, &opt_dvb_adapters },
#endif
{ 0, NULL, "Server Connectivity", OPT_BOOL, NULL },
{ '6', "ipv6", "Listen on IPv6", OPT_BOOL, &opt_ipv6 },
{ 'b', "bindaddr", "Specify bind address", OPT_STR, &opt_bindaddr},
{ 0, "http_port", "Specify alternative http port",
OPT_INT, &tvheadend_webui_port },
{ 0, "http_root", "Specify alternative http webroot",
OPT_STR, &tvheadend_webroot },
{ 0, "htsp_port", "Specify alternative htsp port",
OPT_INT, &tvheadend_htsp_port },
{ 0, "htsp_port2", "Specify extra htsp port",
OPT_INT, &tvheadend_htsp_port_extra },
{ 0, NULL, "Debug Options", OPT_BOOL, NULL },
{ 'd', "stderr", "Enable debug on stderr", OPT_BOOL, &opt_stderr },
{ 's', "syslog", "Enable debug to syslog", OPT_BOOL, &opt_syslog },
{ 'l', "logfile", "Enable debug to file", OPT_STR, &opt_logpath },
{ 0, "debug", "Enable debug subsystems", OPT_STR, &opt_log_debug },
#if ENABLE_TRACE
{ 0, "trace", "Enable trace subsystems", OPT_STR, &opt_log_trace },
#endif
{ 0, "fileline", "Add file and line numbers to debug", OPT_BOOL, &opt_fileline },
{ 0, "threadid", "Add the thread ID to debug", OPT_BOOL, &opt_threadid },
{ 0, "uidebug", "Enable webUI debug (non-minified JS)", OPT_BOOL, &opt_uidebug },
{ 'A', "abort", "Immediately abort", OPT_BOOL, &opt_abort },
{ 'D', "dump", "Enable coredumps for daemon", OPT_BOOL, &opt_dump },
{ 0, "noacl", "Disable all access control checks",
OPT_BOOL, &opt_noacl },
{ 'j', "join", "Subscribe to a service permanently",
OPT_STR, &opt_subscribe },
{ 0, NULL, "TODO: testing", OPT_BOOL, NULL },
{ 0, "tsfile_tuners", "Number of tsfile tuners", OPT_INT, &opt_tsfile_tuner },
{ 0, "tsfile", "tsfile input (mux file)", OPT_STR_LIST, &opt_tsfile },
};
/* Get current directory */
tvheadend_cwd = dirname(dirname(tvh_strdupa(argv[0])));
/* Set locale */
setlocale(LC_ALL, "");
setlocale(LC_NUMERIC, "C");
/* make sure the timezone is set */
tzset();
/* Process command line */
for (i = 1; i < argc; i++) {
/* Find option */
cmdline_opt_t *opt
= cmdline_opt_find(cmdline_opts, ARRAY_SIZE(cmdline_opts), argv[i]);
if (!opt)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts),
"invalid option specified [%s]", argv[i]);
/* Process */
if (opt->type == OPT_BOOL)
*((int*)opt->param) = 1;
else if (++i == argc)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts),
"option %s requires a value", opt->lopt);
else if (opt->type == OPT_INT)
*((int*)opt->param) = atoi(argv[i]);
else if (opt->type == OPT_STR_LIST) {
str_list_t *strl = opt->param;
if (strl->num < strl->max)
strl->str[strl->num++] = argv[i];
}
else
*((char**)opt->param) = argv[i];
/* Stop processing */
if (opt_help)
show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts), NULL);
if (opt_version)
show_version(argv[0]);
}
/* Additional cmdline processing */
#if ENABLE_LINUXDVB
if (!opt_dvb_adapters) {
adapter_mask = ~0;
} else {
char *p, *e;
char *r = NULL;
char *dvb_adapters = strdup(opt_dvb_adapters);
adapter_mask = 0x0;
p = strtok_r(dvb_adapters, ",", &r);
while (p) {
int a = strtol(p, &e, 10);
if (*e != 0 || a < 0 || a > 31) {
tvhlog(LOG_ERR, "START", "Invalid adapter number '%s'", p);
free(dvb_adapters);
return 1;
}
adapter_mask |= (1 << a);
p = strtok_r(NULL, ",", &r);
}
free(dvb_adapters);
if (!adapter_mask) {
tvhlog(LOG_ERR, "START", "No adapters specified!");
return 1;
}
}
#endif
if (tvheadend_webroot) {
char *tmp;
if (*tvheadend_webroot == '/')
tmp = strdup(tvheadend_webroot);
else {
tmp = malloc(strlen(tvheadend_webroot)+2);
*tmp = '/';
strcpy(tmp+1, tvheadend_webroot);
}
if (tmp[strlen(tmp)-1] == '/')
tmp[strlen(tmp)-1] = '\0';
tvheadend_webroot = tmp;
}
tvheadend_webui_debug = opt_uidebug;
/* Setup logging */
if (isatty(2))
log_options |= TVHLOG_OPT_DECORATE;
if (opt_stderr || opt_syslog || opt_logpath) {
if (!opt_log_trace && !opt_log_debug)
log_debug = "all";
log_level = LOG_DEBUG;
if (opt_stderr)
log_options |= TVHLOG_OPT_DBG_STDERR;
if (opt_syslog)
log_options |= TVHLOG_OPT_DBG_SYSLOG;
if (opt_logpath)
log_options |= TVHLOG_OPT_DBG_FILE;
}
if (opt_fileline)
log_options |= TVHLOG_OPT_FILELINE;
if (opt_threadid)
log_options |= TVHLOG_OPT_THREAD;
if (opt_log_trace) {
log_level = LOG_TRACE;
log_trace = opt_log_trace;
}
if (opt_log_debug)
log_debug = opt_log_debug;
tvhlog_init(log_level, log_options, opt_logpath);
tvhlog_set_debug(log_debug);
tvhlog_set_trace(log_trace);
signal(SIGPIPE, handle_sigpipe); // will be redundant later
/* Daemonise */
if(opt_fork) {
const char *homedir;
gid_t gid;
uid_t uid;
struct group *grp = getgrnam(opt_group ?: "video");
struct passwd *pw = opt_user ? getpwnam(opt_user) : NULL;
FILE *pidfile = fopen(opt_pidpath, "w+");
if(grp != NULL) {
gid = grp->gr_gid;
} else {
gid = 1;
}
if (pw != NULL) {
if (getuid() != pw->pw_uid) {
gid_t glist[10];
int gnum;
gnum = get_user_groups(pw, glist, 10);
if (setgroups(gnum, glist)) {
tvhlog(LOG_ALERT, "START",
"setgroups() failed, do you have permission?");
return 1;
}
}
uid = pw->pw_uid;
homedir = pw->pw_dir;
setenv("HOME", homedir, 1);
} else {
uid = 1;
}
if ((getgid() != gid) && setgid(gid)) {
tvhlog(LOG_ALERT, "START",
"setgid() failed, do you have permission?");
return 1;
}
if ((getuid() != uid) && setuid(uid)) {
tvhlog(LOG_ALERT, "START",
"setuid() failed, do you have permission?");
return 1;
}
if(daemon(0, 0)) {
exit(2);
}
if(pidfile != NULL) {
fprintf(pidfile, "%d\n", getpid());
fclose(pidfile);
}
/* Make dumpable */
if (opt_dump) {
#ifdef PLATFORM_LINUX
if (chdir("/tmp"))
tvhwarn("START", "failed to change cwd to /tmp");
prctl(PR_SET_DUMPABLE, 1);
#else
tvhwarn("START", "Coredumps not implemented on your platform");
#endif
}
umask(0);
}
tvheadend_running = 1;
/* Start log thread (must be done post fork) */
tvhlog_start();
/* Alter logging */
if (opt_fork)
tvhlog_options &= ~TVHLOG_OPT_STDERR;
if (!isatty(2))
tvhlog_options &= ~TVHLOG_OPT_DECORATE;
/* Initialise clock */
pthread_mutex_lock(&global_lock);
time(&dispatch_clock);
/* Signal handling */
sigfillset(&set);
sigprocmask(SIG_BLOCK, &set, NULL);
trap_init(argv[0]);
/* Initialise configuration */
uuid_init();
idnode_init();
config_init(opt_config);
/**
* Initialize subsystems
*/
api_init();
fsmonitor_init();
#if ENABLE_LIBAV
libav_init();
transcoding_init();
#endif
imagecache_init();
service_init();
#if ENABLE_TSFILE
if(opt_tsfile.num) {
tsfile_init(opt_tsfile_tuner ?: opt_tsfile.num);
for (i = 0; i < opt_tsfile.num; i++)
tsfile_add_file(opt_tsfile.str[i]);
}
#endif
#if ENABLE_MPEGTS_DVB
dvb_network_init();
#endif
#if ENABLE_IPTV
iptv_init();
#endif
#if ENABLE_LINUXDVB
linuxdvb_init(adapter_mask);
#endif
channel_init();
subscription_init();
access_init(opt_firstrun, opt_noacl);
#if ENABLE_TIMESHIFT
timeshift_init();
#endif
http_client_init();
tcp_server_init(opt_ipv6);
http_server_init(opt_bindaddr);
webui_init();
service_mapper_init();
descrambler_init();
epggrab_init();
epg_init();
dvr_init();
htsp_init(opt_bindaddr);
if(opt_subscribe != NULL)
subscription_dummy_join(opt_subscribe, 1);
avahi_init();
epg_updated(); // cleanup now all prev ref's should have been created
pthread_mutex_unlock(&global_lock);
/**
* Wait for SIGTERM / SIGINT, but only in this thread
*/
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
signal(SIGTERM, doexit);
signal(SIGINT, doexit);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
tvhlog(LOG_NOTICE, "START", "HTS Tvheadend version %s started, "
"running as PID:%d UID:%d GID:%d, CWD:%s CNF:%s",
tvheadend_version,
getpid(), getuid(), getgid(), getcwd(buf, sizeof(buf)),
hts_settings_get_root());
if(opt_abort)
abort();
mainloop();
tvhftrace("main", htsp_done);
tvhftrace("main", http_server_done);
tvhftrace("main", webui_done);
tvhftrace("main", http_client_done);
tvhftrace("main", fsmonitor_done);
#if ENABLE_MPEGTS_DVB
tvhftrace("main", dvb_network_done);
#endif
#if ENABLE_IPTV
tvhftrace("main", iptv_done);
#endif
#if ENABLE_LINUXDVB
tvhftrace("main", linuxdvb_done);
#endif
#if ENABLE_TSFILE
tvhftrace("main", tsfile_done);
#endif
// Note: the locking is obviously a bit redundant, but without
// we need to disable the gtimer_arm call in epg_save()
pthread_mutex_lock(&global_lock);
tvhftrace("main", epg_save);
#if ENABLE_TIMESHIFT
tvhftrace("main", timeshift_term);
#endif
pthread_mutex_unlock(&global_lock);
tvhftrace("main", epggrab_done);
tvhftrace("main", tcp_server_done);
tvhftrace("main", descrambler_done);
tvhftrace("main", service_mapper_done);
tvhftrace("main", service_done);
tvhftrace("main", channel_done);
tvhftrace("main", dvr_done);
tvhftrace("main", subscription_done);
tvhftrace("main", access_done);
tvhftrace("main", epg_done);
tvhftrace("main", avahi_done);
tvhftrace("main", imagecache_done);
tvhftrace("main", idnode_done);
tvhftrace("main", lang_code_done);
tvhftrace("main", api_done);
tvhftrace("main", config_done);
tvhftrace("main", hts_settings_done);
tvhftrace("main", dvb_done);
tvhftrace("main", lang_str_done);
tvhlog(LOG_NOTICE, "STOP", "Exiting HTS Tvheadend");
tvhlog_end();
if(opt_fork)
unlink(opt_pidpath);
free(opt_tsfile.str);
return 0;
}
static int do_update_alias_table(ddns_t *ctx)
{
int i, j;
int rc = 0, rc2;
http_trans_t http_tr;
int anychange = 0;
for (i = 0; i < ctx->info_count; i++) {
ddns_info_t *info = &ctx->info[i];
for (j = 0; j < info->alias_count; j++) {
if (info->alias[j].update_required != 1) {
continue;
}
rc = http_client_init(&ctx->http_to_dyndns[i], "Sending IP# update to DDNS server");
if (rc != 0) {
break;
}
/* Build dyndns transaction */
http_tr.req_len = info->system->update_request_func(ctx, i, j);
http_tr.p_req = (char *)ctx->request_buf;
http_tr.p_rsp = (char *)ctx->work_buf;
http_tr.max_rsp_len = ctx->work_buflen - 1; /* Save place for a \0 at the end */
http_tr.rsp_len = 0;
rc = http_client_transaction(&ctx->http_to_dyndns[i], &http_tr);
http_tr.p_rsp[http_tr.rsp_len] = 0;
if (ctx->dbg.level > 2) {
ctx->request_buf[http_tr.req_len] = 0;
logit(LOG_DEBUG, "Sending alias table update to DDNS server:");
logit(LOG_DEBUG, "%s", ctx->request_buf);
}
if (rc == 0) {
rc = info->system->response_ok_func(ctx, &http_tr, i);
if (rc == 0) {
info->alias[j].update_required = 0;
logit(LOG_INFO,
"Successful alias table update for %s => new IP# %s",
info->alias[j].names.name, info->my_ip_address.name);
ctx->time_since_last_update = 0;
ctx->force_addr_update = 0;
anychange++;
} else {
logit(LOG_WARNING,
"%s error in DDNS server response:",
rc == RC_DYNDNS_RSP_RETRY_LATER ? "Temporary" : "Fatal");
logit(LOG_WARNING, "[%d %s] %s",
http_tr.status,
http_tr.status_desc,
http_tr.p_rsp_body != http_tr.p_rsp ? http_tr.p_rsp_body : "");
}
if (ctx->dbg.level > 2) {
logit(LOG_DEBUG, "DDNS server response:");
logit(LOG_DEBUG, "%s", http_tr.p_rsp);
}
}
rc2 = http_client_shutdown(&ctx->http_to_dyndns[i]);
if (rc == 0) {
/* Only overwrite rc with of http_client_shutdown() rc if previous call, in
* e.g., http_client_transaction() or the response_ok_func() callback was OK. */
rc = rc2;
}
if (rc != 0) {
break;
}
os_sleep_ms(1000);
}
}
/* Successful change or when cache file does not yet exist! */
if (anychange || access(ctx->cache_file, F_OK)) {
FILE *fp;
/* Update cache with new IP */
fp = fopen(ctx->cache_file, "w");
if (fp) {
fprintf(fp, "%s", ctx->info[0].my_ip_address.name);
fclose(fp);
}
/* Run external command hook on update. */
if (anychange && ctx->external_command) {
os_shell_execute(ctx->external_command,
ctx->info[0].my_ip_address.name,
ctx->info[0].alias[0].names.name, ctx->bind_interface);
}
}
return rc;
}
static RC_TYPE do_update_alias_table(DYN_DNS_CLIENT *p_self)
{
int i;
int shutdown = 0;
RC_TYPE rc = RC_OK;
FILE *fp;
do
{
for (i = 0; i < p_self->alias_info.count; ++i)
{
if (p_self->alias_info.update_required[i] != TRUE)
{
continue;
}
rc = http_client_init(&p_self->http_to_dyndns);
if (rc != RC_OK)
{
break;
}
/*build dyndns transaction*/
{
HTTP_TRANSACTION http_tr;
http_tr.req_len = p_self->info.p_dns_system->p_dns_update_req_func(
(struct _DYN_DNS_CLIENT*) p_self,i,
(struct DYNDNS_SYSTEM*) p_self->info.p_dns_system);
http_tr.p_req = (char*) p_self->p_req_buffer;
http_tr.p_rsp = (char*) p_self->p_work_buffer;
http_tr.max_rsp_len = p_self->work_buffer_size - 1;/*save place for a \0 at the end*/
http_tr.rsp_len = 0;
p_self->p_work_buffer[http_tr.rsp_len+1] = 0;
/*send it*/
rc = http_client_transaction(&p_self->http_to_dyndns, &http_tr);
if (p_self->dbg.level > 2)
{
p_self->p_req_buffer[http_tr.req_len] = 0;
DBG_PRINTF((LOG_DEBUG,"DYNDNS my Request:\n%s\n", p_self->p_req_buffer));
}
if (rc == RC_OK)
{
int rc = p_self->info.p_dns_system->p_rsp_ok_func((struct _DYN_DNS_CLIENT*)p_self, http_tr.p_rsp,
p_self->info.p_dns_system->p_success_string);
if (rc == RC_OK)
{
p_self->alias_info.update_required[i] = FALSE;
DBG_PRINTF((LOG_WARNING,"I:" MODULE_TAG "Alias '%s' to IP '%s' updated successfully.\n",
p_self->alias_info.names[i].name,
p_self->info.my_ip_address.name));
p_self->times_since_last_update = 0;
/*recalc forced update period*/
p_self->forced_update_period_sec = p_self->forced_update_period_sec_orig;
p_self->forced_update_times = p_self->forced_update_period_sec / p_self->sleep_sec;
if ((fp=fopen(p_self->ip_cache, "w")))
{
fprintf(fp,"%s", p_self->info.my_ip_address.name);
fclose(fp);
}
if ((fp=fopen(p_self->time_cache, "w")))
{
fprintf(fp,"%ld", time (NULL));
fclose(fp);
}
if (strlen(p_self->external_command) > 0)
os_shell_execute(p_self->external_command);
}
else
{
DBG_PRINTF((LOG_WARNING,"W:" MODULE_TAG "Response Code: %d\n", rc));
DBG_PRINTF((LOG_WARNING,"W:" MODULE_TAG "Error validating DYNDNS svr answer. Check usr,pass,hostname! (%s)\n", http_tr.p_rsp));
shutdown++;
}
if (p_self->dbg.level > 2)
{
http_tr.p_rsp[http_tr.rsp_len] = 0;
DBG_PRINTF((LOG_WARNING,"W:" MODULE_TAG "DYNDNS Server response:\n%s\n", http_tr.p_rsp));
}
}
}
{
RC_TYPE rc2 = http_client_shutdown(&p_self->http_to_dyndns);
if (rc == RC_OK)
{
rc = rc2;
}
}
if (rc != RC_OK || shutdown>2)
{
break;
}
os_sleep_ms(1000);
}
if (rc != RC_OK)
{
break;
}
}
while(0);
return rc;
}
int main(int argc, char **argv)
{
daemonize_close_stdin();
parse_cmdline(argc, argv);
if (!file_read_config())
g_error("cannot read configuration file\n");
log_init(file_config.log, file_config.verbose);
daemonize_init(file_config.daemon_user, file_config.pidfile);
if (!file_config.no_daemon)
daemonize_detach();
daemonize_write_pidfile();
daemonize_set_user();
#ifndef NDEBUG
if (!file_config.no_daemon)
#endif
daemonize_close_stdout_stderr();
main_loop = g_main_loop_new(NULL, FALSE);
lmc_connect(file_config.host, file_config.port);
http_client_init();
as_init(file_config.scrobblers);
setup_signals();
timer = g_timer_new();
/* set up timeouts */
save_source_id = g_timeout_add_seconds(file_config.journal_interval,
timer_save_journal, NULL);
/* run the main loop */
g_main_loop_run(main_loop);
/* cleanup */
g_message("shutting down\n");
g_source_remove(save_source_id);
g_main_loop_unref(main_loop);
g_timer_destroy(timer);
as_save_cache();
as_cleanup();
http_client_finish();
lmc_disconnect();
file_cleanup();
log_deinit();
daemonize_finish();
return 0;
}
void application_start( void )
{
wiced_ip_address_t ip_address;
wiced_result_t result;
/* We need three headers - host, content type, and content length */
http_header_field_t header[3];
/* Header 0 is the Host header */
header[0].field = HTTP_HEADER_HOST;
header[0].field_length = strlen( HTTP_HEADER_HOST );
header[0].value = SERVER_HOST;
header[0].value_length = strlen( SERVER_HOST );
/* Header 1 is the content type (JSON) */
header[1].field = HTTP_HEADER_CONTENT_TYPE;
header[1].field_length = strlen( HTTP_HEADER_CONTENT_TYPE );
header[1].value = "application/json";
header[1].value_length = strlen( "application/json" );
/* Header 2 is the content length. In this case, it is the length of the JSON message */
sprintf(json_len,"%d", strlen(JSON_MSG)); /* Calculate the length of the JSON message and store the value as a string */
header[2].field = HTTP_HEADER_CONTENT_LENGTH;
header[2].field_length = strlen( HTTP_HEADER_CONTENT_LENGTH );
header[2].value = json_len; // This holds the length of the JSON message as a sting containing the decimal value
header[2].value_length = strlen( json_len ); // This is the length of the string that holds the JSON message size. For example, if the JSON is 12 characters, this would be "2" because the string "12" is 2 characters long.
wiced_init( );
/* This semaphore will be used to wait for one request to finish before re-initializing and starting the next one */
wiced_rtos_init_semaphore(&httpWait);
wiced_network_up(WICED_STA_INTERFACE, WICED_USE_EXTERNAL_DHCP_SERVER, NULL);
WPRINT_APP_INFO( ( "Resolving IP address of %s\n", SERVER_HOST ) );
wiced_hostname_lookup( SERVER_HOST, &ip_address, DNS_TIMEOUT_MS, WICED_STA_INTERFACE );
WPRINT_APP_INFO( ( "%s is at %u.%u.%u.%u\n", SERVER_HOST,
(uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 24),
(uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 16),
(uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 8),
(uint8_t)(GET_IPV4_ADDRESS(ip_address) >> 0) ) );
/* Initialize client */
http_client_init( &client, WICED_STA_INTERFACE, event_handler, NULL );
client.peer_cn = NULL; /* If you set hostname, library will make sure subject name in the server certificate is matching with host name you are trying to connect. Pass NULL if you don't want to enable this check */
/* Connect to the server */
if ( ( result = http_client_connect( &client, (const wiced_ip_address_t*)&ip_address, SERVER_PORT, HTTP_NO_SECURITY, CONNECT_TIMEOUT_MS ) ) == WICED_SUCCESS )
{
connected = WICED_TRUE;
WPRINT_APP_INFO( ( "Connected to %s\n", SERVER_HOST ) );
}
else
{
WPRINT_APP_INFO( ( "Error: failed to connect to server: %u\n", result) );
return; /* Connection failed - exit program */
}
/* Send a POST to resource /anything */
http_request_init( &request, &client, HTTP_POST, "/post", HTTP_1_1 );
http_request_write_header( &request, &header[0], 3 ); // We need 3 headers
http_request_write_end_header( &request );
http_request_write( &request, (uint8_t* ) JSON_MSG, strlen(JSON_MSG)); /* Write the content */
http_request_flush( &request );
wiced_rtos_get_semaphore(&httpWait, WICED_WAIT_FOREVER); /* Wait for this request to complete before going on */
/* Disconnect from the server and deinit since we are done now */
http_client_disconnect( &client );
http_client_deinit( &client );
}
static RC_TYPE do_update_alias_table(DYN_DNS_CLIENT *p_self)
{
int i;
RC_TYPE rc = RC_OK;
do
{
for (i = 0; i < p_self->alias_info.count; ++i)
{
if (p_self->alias_info.update_required[i] != TRUE)
{
continue;
}
rc = http_client_init(&p_self->http_to_dyndns);
if (rc != RC_OK)
{
break;
}
/*build dyndns transaction*/
{
HTTP_TRANSACTION http_tr;
http_tr.req_len = p_self->info.p_dns_system->p_dns_update_req_func(
(struct _DYN_DNS_CLIENT*) p_self,i,
(struct DYNDNS_SYSTEM*) p_self->info.p_dns_system);
http_tr.p_req = (char*) p_self->p_req_buffer;
http_tr.p_rsp = (char*) p_self->p_work_buffer;
http_tr.max_rsp_len = p_self->work_buffer_size - 1;/*save place for a \0 at the end*/
http_tr.rsp_len = 0;
p_self->p_work_buffer[http_tr.rsp_len+1] = 0;
/*send it*/
rc = http_client_transaction(&p_self->http_to_dyndns, &http_tr);
if (p_self->dbg.level > 2)
{
p_self->p_req_buffer[http_tr.req_len] = 0;
DBG_PRINTF((LOG_DEBUG,"DYNDNS my Request:\n%s\n", p_self->p_req_buffer));
}
if (rc == RC_OK)
{
BOOL update_ok =
p_self->info.p_dns_system->p_rsp_ok_func((struct _DYN_DNS_CLIENT*)p_self,
http_tr.p_rsp,
p_self->info.p_dns_system->p_success_string);
if (update_ok)
{
p_self->alias_info.update_required[i] = FALSE;
DBG_PRINTF((LOG_WARNING,"I:" MODULE_TAG "Alias '%s' to IP '%s' updated successful.\n",
p_self->alias_info.names[i].name,
p_self->info.my_ip_address.name));
p_self->times_since_last_update = 0;
}
else
{
DBG_PRINTF((LOG_WARNING,"W:" MODULE_TAG "Error validating DYNDNS svr answer. Check usr,pass,hostname!\n", http_tr.p_rsp));
}
if (p_self->dbg.level > 2)
{
http_tr.p_rsp[http_tr.rsp_len] = 0;
DBG_PRINTF((LOG_WARNING,"W:" MODULE_TAG "DYNDNS Server response:\n%s\n", http_tr.p_rsp));
}
}
}
{
RC_TYPE rc2 = http_client_shutdown(&p_self->http_to_dyndns);
if (rc == RC_OK)
{
rc = rc2;
}
}
if (rc != RC_OK)
{
break;
}
os_sleep_ms(1000);
}
if (rc != RC_OK)
{
break;
}
}
while(0);
return rc;
}
