ne_session * opensession_common(const addr_info_t *addr_info, int connect_timeout, int read_timeout, GError **err) { ne_session *session=NULL; gchar host[1024]; guint16 port; if (!addr_info) { GSETERROR (err, "Invalid parameter"); return NULL; } port = 0; memset(host, 0x00, sizeof(host)); if (!addr_info_get_addr(addr_info, host, sizeof(host)-1, &port)) { GSETERROR(err, "AddrInfo printing error"); return NULL; } session = ne_session_create ("http", host, port); if (!session) { GSETERROR(err,"cannot create a new WebDAV session"); return NULL; } ne_set_connect_timeout (session, connect_timeout); ne_set_read_timeout (session, read_timeout); return session; }
rawx_session_t* rawx_client_create_session( addr_info_t *ai, GError **err ) { struct sockaddr_storage ss; gsize ss_size = sizeof(ss); gchar host[256], port[16]; rawx_session_t *session; session = g_try_malloc0( sizeof(rawx_session_t) ); if (!session) { GSETERROR(err,"Memory allocation failure"); goto error_session; } memcpy( &(session->addr), ai, sizeof(addr_info_t) ); if (!addrinfo_to_sockaddr( ai, (struct sockaddr*)&ss, &ss_size )) { GSETERROR(err,"addr_info_t conversion error"); goto error_addr; } memset( host, 0x00, sizeof(host) ); memset( port, 0x00, sizeof(port) ); if (getnameinfo ( (struct sockaddr* )&ss, ss_size, host, sizeof(host), port, sizeof(port), NI_NUMERICHOST|NI_NUMERICSERV)) { GSETERROR(err,"addr_info_t resolution error : %s", strerror(errno)); goto error_addr; } session->neon_session = ne_session_create ("http", host, atoi(port)); if (!session->neon_session) { GSETERROR(err,"neon session creation error"); goto error_neon; } session->timeout.cnx = 60000; session->timeout.req = 60000; ne_set_connect_timeout (session->neon_session, session->timeout.cnx/1000); ne_set_read_timeout (session->neon_session, session->timeout.req/1000); return session; error_neon: error_addr: g_free(session); error_session: return NULL; }
static gboolean _ne_request(const char *host, int port, const char *target, const char *method, GSList *headers, GError **err) { GRID_TRACE("%s", __FUNCTION__); gboolean result = FALSE; ne_session* session = ne_session_create("http", host, port); ne_set_connect_timeout(session, 10); ne_set_read_timeout(session, 30); GRID_DEBUG("%s http://%s:%d%s", method, host, port, target); ne_request* req = ne_request_create(session, method, target); if (NULL != req) { for (GSList *l = headers; l; l = l->next) { gchar **toks = g_strsplit(l->data, ":", 2); ne_add_request_header(req, toks[0], toks[1]); g_strfreev(toks); } switch (ne_request_dispatch(req)) { case NE_OK: if (ne_get_status(req)->klass != 2) { *err = NEWERROR(0, "cannot %s '%s' (%s)", method, target, ne_get_error(session)); } else { result = TRUE; } break; case NE_AUTH: case NE_CONNECT: case NE_TIMEOUT: case NE_ERROR: default: *err = NEWERROR(0, "unexpected error from the WebDAV server (%s)", ne_get_error(session)); break; } ne_request_destroy(req); } else { // This should be an assertion *err = NEWERROR(0, "Failed to create request"); } ne_session_destroy (session); return result; }
static char * _check_chunk(const char *cid) { ne_session *session=NULL; ne_request *request=NULL; GString *str = g_string_new(""); char **split = g_strsplit(cid, "/", 0); char **addr_tok = g_strsplit(split[2], ":", 2); if(NULL != (session = ne_session_create("http", addr_tok[0], atoi(addr_tok[1])))) { ne_set_connect_timeout(session, 10); ne_set_read_timeout(session, 30); /* FIXME: I'm a little harder with strrchr success presumption */ if(NULL != (request = ne_request_create (session, "HEAD", strrchr(cid, '/')))) { switch (ne_request_dispatch (request)) { case NE_OK: if (ne_get_status(request)->klass != 2) { g_string_append_printf(str, "(Chunk unavailable : %s)", ne_get_error(session)); } break; default: g_string_append_printf(str, "(Chunk unavailable : %s)", ne_get_error(session)); } ne_request_destroy (request); } ne_session_destroy (session); } g_strfreev(addr_tok); g_strfreev(split); return g_string_free(str, FALSE); }
int main_http_config(const gchar *hn, int fd) { int rc; GError *error = NULL; GByteArray *gba_services = NULL; GByteArray *gba_files = NULL; ne_session *http_session; set_sighandlers(); fd_out = fd; DEBUG("Starting a new configuration process"); rc = -1; bzero(hostname, sizeof(hostname)); if (!hn) gethostname(hostname,sizeof(hostname)); else g_strlcpy(hostname, hn, sizeof(hostname)-1); http_session = ne_session_create("http", gridconf_host, gridconf_port); ne_set_connect_timeout(http_session, 1); ne_set_read_timeout(http_session, 4); /*downlaod each file*/ if (!is_running) goto label_error; gba_files = download_file_list(http_session, &error); if (!gba_files) { ERROR("Failed to get the files list file : %s", gerror_get_message(error)); goto label_error; } if (!is_running) goto label_error; gba_services = download_file_services(http_session, &error); if (!gba_services) { ERROR("Failed to get the services definition file : %s", gerror_get_message(error)); goto label_error; } if (!is_running) goto label_error; if (!download_each_configuration_file(http_session, gba_files, &error)) { ERROR("Failed to download a configuration file : %s", gerror_get_message(error)); goto label_error; } if (!is_running) goto label_error; if (!dump_gba(gba_services, fd_out, &error)) { ERROR("Failed to dump the configuration to fd=%d : %s", fd_out, gerror_get_message(error)); goto label_error; } rc = 0; label_error: ne_session_destroy(http_session); metautils_pclose(&fd_out); if (gba_services) g_byte_array_free(gba_services, TRUE); if (gba_files) g_byte_array_free(gba_files, TRUE); DEBUG("http_config child pid=%d exiting with rc=%d", getpid(), rc); return rc; }
static int open_handle (struct neon_handle * handle, uint64_t startbyte) { int ret; char * proxy_host = NULL; int proxy_port = 0; bool_t use_proxy = aud_get_bool (NULL, "use_proxy"); bool_t use_proxy_auth = aud_get_bool (NULL, "use_proxy_auth"); if (use_proxy) { proxy_host = aud_get_str (NULL, "proxy_host"); proxy_port = aud_get_int (NULL, "proxy_port"); } handle->redircount = 0; _DEBUG ("<%p> Parsing URL", handle); if (ne_uri_parse (handle->url, handle->purl) != 0) { _ERROR ("<%p> Could not parse URL '%s'", (void *) handle, handle->url); return -1; } while (handle->redircount < 10) { if (! handle->purl->port) handle->purl->port = ne_uri_defaultport (handle->purl->scheme); _DEBUG ("<%p> Creating session to %s://%s:%d", handle, handle->purl->scheme, handle->purl->host, handle->purl->port); handle->session = ne_session_create (handle->purl->scheme, handle->purl->host, handle->purl->port); ne_redirect_register (handle->session); ne_add_server_auth (handle->session, NE_AUTH_BASIC, server_auth_callback, (void *) handle); ne_set_session_flag (handle->session, NE_SESSFLAG_ICYPROTO, 1); ne_set_session_flag (handle->session, NE_SESSFLAG_PERSIST, 0); #ifdef HAVE_NE_SET_CONNECT_TIMEOUT ne_set_connect_timeout (handle->session, 10); #endif ne_set_read_timeout (handle->session, 10); ne_set_useragent (handle->session, "Audacious/" PACKAGE_VERSION); if (use_proxy) { _DEBUG ("<%p> Using proxy: %s:%d", handle, proxy_host, proxy_port); ne_session_proxy (handle->session, proxy_host, proxy_port); if (use_proxy_auth) { _DEBUG ("<%p> Using proxy authentication", handle); ne_add_proxy_auth (handle->session, NE_AUTH_BASIC, neon_proxy_auth_cb, (void *) handle); } } if (! strcmp ("https", handle->purl->scheme)) { ne_ssl_trust_default_ca (handle->session); ne_ssl_set_verify (handle->session, neon_vfs_verify_environment_ssl_certs, handle->session); } _DEBUG ("<%p> Creating request", handle); ret = open_request (handle, startbyte); if (! ret) { str_unref (proxy_host); return 0; } if (ret == -1) { ne_session_destroy (handle->session); handle->session = NULL; str_unref (proxy_host); return -1; } _DEBUG ("<%p> Following redirect...", handle); ne_session_destroy (handle->session); handle->session = NULL; } /* If we get here, our redirect count exceeded */ _ERROR ("<%p> Redirect count exceeded for URL %s", (void *) handle, handle->url); str_unref (proxy_host); return 1; }
GHashTable * rawx_client_get_statistics(rawx_session_t * session, const gchar *url, GError ** err) { int rc; gchar str_addr[64]; gsize str_addr_size; GHashTable *parsed = NULL; GHashTable *result = NULL; GByteArray *buffer = NULL; ne_request *request = NULL; if (!session || !url) { GSETERROR(err, "Invalid parameter"); return NULL; } ne_set_connect_timeout(session->neon_session, session->timeout.cnx / 1000); ne_set_read_timeout(session->neon_session, session->timeout.req / 1000); request = ne_request_create(session->neon_session, "GET", url); if (!request) { GSETERROR(err, "neon request creation error"); return NULL; } buffer = g_byte_array_new(); ne_add_response_body_reader(request, ne_accept_2xx, body_reader, buffer); switch (rc = ne_request_dispatch(request)) { case NE_OK: if (ne_get_status(request)->klass != 2) { GSETERROR(err, "RAWX returned an error"); goto exit; } else if (!(parsed = body_parser(buffer, err))) { GSETERROR(err, "No statistics from the RAWX server"); goto exit; } break; case NE_ERROR: case NE_TIMEOUT: case NE_CONNECT: case NE_AUTH: str_addr_size = addr_info_to_string(&(session->addr), str_addr, sizeof(str_addr)); GSETERROR(err, "cannot download the stats from [%.*s]' (%s)", (int)str_addr_size, str_addr, ne_get_error(session->neon_session)); goto exit; default: GSETERROR(err, "Unexpected return code from the neon library : %d", rc); goto exit; } result = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); g_hash_table_foreach(parsed, _convert_string_to_double, result); exit: if (buffer != NULL) g_byte_array_free(buffer, TRUE); if (request != NULL) ne_request_destroy(request); if (parsed != NULL) g_hash_table_destroy(parsed); return result; }
gboolean rawx_client_get_directory_data(rawx_session_t * session, hash_sha256_t chunk_id, struct content_textinfo_s *content, struct chunk_textinfo_s *chunk, GError ** error) { int rc; gchar str_addr[64]; gsize str_addr_size; gchar str_req[2048]; gchar str_chunk_id[(sizeof(hash_sha256_t) * 2) + 1]; GHashTable *result = NULL; GByteArray *buffer = NULL; ne_request *request = NULL; if (!session) { GSETERROR(error, "Invalid parameter"); return FALSE; } memset(str_chunk_id, '\0', sizeof(str_chunk_id)); oio_str_bin2hex(chunk_id, sizeof(hash_sha256_t), str_chunk_id, sizeof(str_chunk_id)); memset(str_req, '\0', sizeof(str_req)); snprintf(str_req, sizeof(str_req) - 1, "%s/%s", RAWX_REQ_GET_DIRINFO, str_chunk_id); ne_set_connect_timeout(session->neon_session, session->timeout.cnx / 1000); ne_set_read_timeout(session->neon_session, session->timeout.req / 1000); request = ne_request_create(session->neon_session, "HEAD", str_req); if (!request) { GSETERROR(error, "neon request creation error"); return FALSE; } buffer = g_byte_array_new(); ne_add_response_body_reader(request, ne_accept_2xx, body_reader, buffer); switch (rc = ne_request_dispatch(request)) { case NE_OK: if (ne_get_status(request)->klass != 2) { GSETERROR(error, "RAWX returned an error %d : %s", ne_get_status(request)->code, ne_get_status(request)->reason_phrase); goto error; } else if (!(result = header_parser(request))) { GSETERROR(error, "No attr from the RAWX server"); goto error; } break; case NE_ERROR: case NE_TIMEOUT: case NE_CONNECT: case NE_AUTH: str_addr_size = addr_info_to_string(&(session->addr), str_addr, sizeof(str_addr)); GSETERROR(error, "cannot download the data from [%.*s]' (%s)", (int)str_addr_size, str_addr, ne_get_error(session->neon_session)); goto error; default: GSETERROR(error, "Unexpected return code from the neon library : %d", rc); goto error; } g_byte_array_free(buffer, TRUE); ne_request_destroy(request); /* Fill the textinfo structs */ parse_chunkinfo_from_rawx(result, content, chunk); g_hash_table_destroy(result); return TRUE; error: g_byte_array_free(buffer, TRUE); ne_request_destroy(request); return FALSE; }
static gboolean _rawx_update_chunk_attrs(chunk_id_t *cid, GSList *attrs, GError **err) { ne_session *s = NULL; ne_request *r = NULL; int ne_rc; gboolean result = FALSE; gchar dst[128]; guint16 port = 0; GString *req_str = NULL; char idstr[65]; if (!addr_info_get_addr(&(cid->addr), dst, sizeof(dst), &port)) return result; s = ne_session_create("http", dst, port); if (!s) { GSETERROR(err, "Failed to create session to rawx %s:%d", dst, port); return result; } ne_set_connect_timeout(s, 10); ne_set_read_timeout(s, 30); req_str =g_string_new("/rawx/chunk/set/"); bzero(idstr, sizeof(idstr)); buffer2str(&(cid->id), sizeof(cid->id), idstr, sizeof(idstr)); req_str = g_string_append(req_str, idstr); GRID_TRACE("Calling %s", req_str->str); r = ne_request_create (s, "GET", req_str->str); if (!r) { goto end_attr; } for (; attrs != NULL; attrs = attrs->next) { struct chunk_attr_s *attr = attrs->data; ne_add_request_header(r, attr->key, attr->val); } switch (ne_rc = ne_request_dispatch(r)) { case NE_OK: result = TRUE; break; case NE_ERROR: GSETCODE(err, 500, "Request NE_ERROR"); break; case NE_TIMEOUT: GSETCODE(err, 500, "Request Timeout"); break; case NE_CONNECT: GSETCODE(err, 500, "Request Connection timeout"); break; default: GSETCODE(err, 500, "Request failed"); break; } end_attr: if (NULL != req_str) g_string_free(req_str, TRUE); if (NULL != r) ne_request_destroy (r); if (NULL != s) ne_session_destroy (s); return result; }
void upsdrv_initups(void) { int ret; char *val; FILE *fp; #if HAVE_NE_SET_CONNECT_TIMEOUT && HAVE_NE_SOCK_CONNECT_TIMEOUT /* we don't need to use alarm() */ #else struct sigaction sa; sigemptyset(&sa.sa_mask); sa.sa_flags = 0; sa.sa_handler = netxml_alarm_handler; sigaction(SIGALRM, &sa, NULL); #endif /* allow override of default network timeout value */ val = getval("timeout"); if (val) { timeout = atoi(val); if (timeout < 1) { fatalx(EXIT_FAILURE, "timeout must be greater than 0"); } } val = getval("shutdown_duration"); if (val) { shutdown_duration = atoi(val); if (shutdown_duration < 0) { fatalx(EXIT_FAILURE, "shutdown duration must be greater than or equal to 0"); } } val = getval("shutdown_timer"); if (val) { shutdown_timer = atoi(val); if (shutdown_timer < 0) { fatalx(EXIT_FAILURE, "shutdown timer must be greater than or equal to 0"); } } if (nut_debug_level > 5) { ne_debug_init(stderr, NE_DBG_HTTP | NE_DBG_HTTPBODY); } if (ne_sock_init()) { fatalx(EXIT_FAILURE, "%s: failed to initialize socket libraries", progname); } if (ne_uri_parse(device_path, &uri) || uri.host == NULL) { fatalx(EXIT_FAILURE, "%s: invalid hostname '%s'", progname, device_path); } /* if (uri.scheme == NULL) { uri.scheme = strdup("http"); } if (uri.host == NULL) { uri.host = strdup(device_path); } */ if (uri.port == 0) { uri.port = ne_uri_defaultport(uri.scheme); } upsdebugx(1, "using %s://%s port %d", uri.scheme, uri.host, uri.port); session = ne_session_create(uri.scheme, uri.host, uri.port); /* timeout if we can't (re)connect to the UPS */ #ifdef HAVE_NE_SET_CONNECT_TIMEOUT ne_set_connect_timeout(session, timeout); #endif /* just wait for a couple of seconds */ ne_set_read_timeout(session, timeout); ne_set_useragent(session, subdriver->version); if (strcasecmp(uri.scheme, "https") == 0) { ne_ssl_trust_default_ca(session); } ne_set_server_auth(session, netxml_authenticate, NULL); /* if debug level is set, direct output to stderr */ if (!nut_debug_level) { fp = fopen("/dev/null", "w"); } else { fp = stderr; } if (!fp) { fatal_with_errno(EXIT_FAILURE, "Connectivity test failed"); } /* see if we have a connection */ ret = ne_get(session, subdriver->initups, fileno(fp)); if (!nut_debug_level) { fclose(fp); } else { fprintf(fp, "\n"); } if (ret != NE_OK) { fatalx(EXIT_FAILURE, "Connectivity test: %s", ne_get_error(session)); } upslogx(LOG_INFO, "Connectivity test: %s", ne_get_error(session)); }
/* Try to send the HTTP request to the Icecast server, and if possible deals with * all the probable redirections (HTTP status code == 3xx) */ static gint gst_neonhttp_src_send_request_and_redirect (GstNeonhttpSrc * src, ne_session ** ses, ne_request ** req, gint64 offset, gboolean do_redir) { ne_session *session = NULL; ne_request *request = NULL; gchar **c; gint res; gint http_status = 0; guint request_count = 0; do { if (src->proxy.host && src->proxy.port) { session = ne_session_create (src->uri.scheme, src->uri.host, src->uri.port); ne_session_proxy (session, src->proxy.host, src->proxy.port); } else if (src->proxy.host || src->proxy.port) { /* both proxy host and port must be specified or none */ return HTTP_REQUEST_WRONG_PROXY; } else { session = ne_session_create (src->uri.scheme, src->uri.host, src->uri.port); } if (src->connect_timeout > 0) { ne_set_connect_timeout (session, src->connect_timeout); } if (src->read_timeout > 0) { ne_set_read_timeout (session, src->read_timeout); } ne_set_session_flag (session, NE_SESSFLAG_ICYPROTO, 1); ne_ssl_set_verify (session, ssl_verify_callback, src); request = ne_request_create (session, "GET", src->query_string); if (src->user_agent) { ne_add_request_header (request, "User-Agent", src->user_agent); } for (c = src->cookies; c != NULL && *c != NULL; ++c) { GST_INFO ("Adding header Cookie : %s", *c); ne_add_request_header (request, "Cookies", *c); } if (src->iradio_mode) ne_add_request_header (request, "icy-metadata", "1"); if (offset > 0) { ne_print_request_header (request, "Range", "bytes=%" G_GINT64_FORMAT "-", offset); } res = ne_begin_request (request); if (res == NE_OK) { /* When the HTTP status code is 3xx, it is not the SHOUTcast streaming content yet; * Reload the HTTP request with a new URI value */ http_status = ne_get_status (request)->code; if (STATUS_IS_REDIRECTION (http_status) && do_redir) { const gchar *redir; /* the new URI value to go when redirecting can be found on the 'Location' HTTP header */ redir = ne_get_response_header (request, "Location"); if (redir != NULL) { ne_uri_free (&src->uri); gst_neonhttp_src_set_location (src, redir, NULL); GST_LOG_OBJECT (src, "Got HTTP Status Code %d", http_status); GST_LOG_OBJECT (src, "Using 'Location' header [%s]", src->uri.host); } } } if ((res != NE_OK) || (offset == 0 && http_status != 200) || (offset > 0 && http_status != 206 && !STATUS_IS_REDIRECTION (http_status))) { ne_request_destroy (request); request = NULL; ne_close_connection (session); ne_session_destroy (session); session = NULL; if (offset > 0 && http_status != 206 && !STATUS_IS_REDIRECTION (http_status)) { src->seekable = FALSE; } } /* if - NE_OK */ if (STATUS_IS_REDIRECTION (http_status) && do_redir) { ++request_count; GST_LOG_OBJECT (src, "redirect request_count is now %d", request_count); if (request_count < MAX_HTTP_REDIRECTS_NUMBER && do_redir) { GST_INFO_OBJECT (src, "Redirecting to %s", src->uri.host); } else { GST_WARNING_OBJECT (src, "Will not redirect, try again with a " "different URI or redirect location %s", src->uri.host); } /* FIXME: when not redirecting automatically, shouldn't we post a * redirect element message on the bus? */ } /* do the redirect, go back to send another HTTP request now using the 'Location' */ } while (do_redir && (request_count < MAX_HTTP_REDIRECTS_NUMBER) && STATUS_IS_REDIRECTION (http_status)); if (session) { *ses = session; *req = request; } return res; }