/*
* Setup HTTP(S) connection
*/
static int
iptv_http_start
( iptv_mux_t *im, const char *raw, const url_t *u )
{
http_client_t *hc;
int r;
if (!(hc = http_client_connect(im, HTTP_VERSION_1_1, u->scheme,
u->host, u->port, NULL)))
return SM_CODE_TUNING_FAILED;
hc->hc_hdr_create = iptv_http_create_header;
hc->hc_hdr_received = iptv_http_header;
hc->hc_data_received = iptv_http_data;
hc->hc_data_complete = iptv_http_complete;
hc->hc_handle_location = 1; /* allow redirects */
hc->hc_io_size = 128*1024; /* increase buffering */
http_client_register(hc); /* register to the HTTP thread */
r = http_client_simple(hc, u);
if (r < 0) {
http_client_close(hc);
return SM_CODE_TUNING_FAILED;
}
im->im_data = hc;
sbuf_init_fixed(&im->mm_iptv_buffer, IPTV_BUF_SIZE);
return 0;
}
static void
satip_discovery_timerq_cb(void *aux)
{
satip_discovery_t *d, *next;
int r;
lock_assert(&global_lock);
next = TAILQ_FIRST(&satip_discoveries);
while (next) {
d = next;
next = TAILQ_NEXT(d, disc_link);
if (d->http_client) {
if (dispatch_clock - d->http_start > 4)
satip_discovery_destroy(d, 1);
continue;
}
d->http_client = http_client_connect(d, HTTP_VERSION_1_1, d->url.scheme,
d->url.host, d->url.port, NULL);
if (d->http_client == NULL)
satip_discovery_destroy(d, 1);
else {
d->http_start = dispatch_clock;
d->http_client->hc_conn_closed = satip_discovery_http_closed;
http_client_register(d->http_client);
r = http_client_simple(d->http_client, &d->url);
if (r < 0)
satip_discovery_destroy(d, 1);
}
}
if (TAILQ_FIRST(&satip_discoveries))
gtimer_arm(&satip_discovery_timerq, satip_discovery_timerq_cb, NULL, 5);
}
/*
* Setup RTSP(S) connection
*/
static int
iptv_rtsp_start
( iptv_mux_t *im, const char *raw, const url_t *u )
{
rtsp_priv_t *rp;
http_client_t *hc;
udp_connection_t *rtp, *rtcp;
int r;
if (!(hc = http_client_connect(im, RTSP_VERSION_1_0, u->scheme,
u->host, u->port, NULL)))
return SM_CODE_TUNING_FAILED;
if (u->user)
hc->hc_rtsp_user = strdup(u->user);
if (u->pass)
hc->hc_rtsp_pass = strdup(u->pass);
if (udp_bind_double(&rtp, &rtcp,
"IPTV", "rtp", "rtcp",
NULL, 0, NULL,
128*1024, 16384, 4*1024, 4*1024) < 0) {
http_client_close(hc);
return SM_CODE_TUNING_FAILED;
}
hc->hc_hdr_received = iptv_rtsp_header;
hc->hc_data_received = iptv_rtsp_data;
hc->hc_handle_location = 1; /* allow redirects */
hc->hc_rtsp_keep_alive_cmd = RTSP_CMD_GET_PARAMETER; /* start keep alive loop with GET_PARAMETER */
http_client_register(hc); /* register to the HTTP thread */
r = rtsp_setup(hc, u->path, u->query, NULL,
ntohs(IP_PORT(rtp->ip)),
ntohs(IP_PORT(rtcp->ip)));
if (r < 0) {
udp_close(rtcp);
udp_close(rtp);
http_client_close(hc);
return SM_CODE_TUNING_FAILED;
}
rp = calloc(1, sizeof(*rp));
rp->rtcp_info = calloc(1, sizeof(iptv_rtcp_info_t));
rtcp_init(rp->rtcp_info);
rp->rtcp_info->connection = rtcp;
rp->hc = hc;
udp_multirecv_init(&rp->um, IPTV_PKTS, IPTV_PKT_PAYLOAD);
rp->path = strdup(u->path ?: "");
rp->query = strdup(u->query ?: "");
im->im_data = rp;
im->mm_iptv_fd = rtp->fd;
im->mm_iptv_connection = rtp;
im->mm_iptv_fd2 = rtcp->fd;
im->mm_iptv_connection2 = rtcp;
return 0;
}
static void
download_fetch(void *aux)
{
download_t *dn = aux;
http_client_t *hc;
url_t u;
urlinit(&u);
if (dn->url == NULL)
goto done;
if (strncmp(dn->url, "file://", 7) == 0) {
download_file(dn, dn->url + 7);
goto done;
}
if (strncmp(dn->url, "pipe://", 7) == 0) {
download_pipe(dn, dn->url + 7);
goto done;
}
if (dn->http_client) {
http_client_close(dn->http_client);
dn->http_client = NULL;
}
if (urlparse(dn->url, &u) < 0) {
tvherror(dn->log, "wrong url");
goto stop;
}
hc = http_client_connect(dn, HTTP_VERSION_1_1, u.scheme, u.host, u.port, NULL);
if (hc == NULL) {
tvherror(dn->log, "unable to open http client");
goto stop;
}
hc->hc_handle_location = 1;
hc->hc_data_limit = 1024*1024;
hc->hc_data_complete = download_fetch_complete;
http_client_register(hc);
http_client_ssl_peer_verify(hc, dn->ssl_peer_verify);
if (http_client_simple(hc, &u) < 0) {
http_client_close(hc);
tvherror(dn->log, "unable to send http command");
goto stop;
}
dn->http_client = hc;
goto done;
stop:
if (dn->stop)
dn->stop(dn->aux);
done:
urlreset(&u);
}
int main( int argc, char** argv )
{
if( argc < 4 )
{
printf("usage: http_tester [GET,SET,PUT] url path\n");
return 1;
}
#if defined( _MSC_VER )
// Initialize Winsock
WSADATA wsaData;
int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (iResult != 0)
{
printf("WSAStartup failed: %d\n", iResult);
return 1;
}
#endif // defined( _MSC_VER )
http_client_t c;
http_client_result res;
res = http_client_connect( &c, argv[2], 0, 0, 0 );
HTTP_ERR_CHECK( res );
if( strcmp( argv[1], "GET" ) == 0 )
{
char* msgbody;
size_t msgbody_size;
res = http_client_get( c, argv[3], (void**)&msgbody, &msgbody_size, 0x0 );
HTTP_ERR_CHECK( res );
fprintf( stdout, "%.*s\n", (int)msgbody_size, msgbody );
free( msgbody );
}
else if( strcmp( argv[1], "HEAD" ) == 0 )
{
size_t msgbody_size;
res = http_client_head( c, argv[3], &msgbody_size);
HTTP_ERR_CHECK( res );
printf( "content size: %lu\n", msgbody_size );
}
else if( strcmp( argv[1], "PUT" ) == 0 )
{
res = http_client_put( c, argv[3], "apansson", 9 );
HTTP_ERR_CHECK( res );
}
http_client_disconnect( c );
free( c );
return 0;
}
int
pmhttpClientFetch(http_client *cp, const char *url,
char *body_buffer, size_t body_length,
char *type_buffer, size_t type_length)
{
int sts = 0, redirected = 0;
if (pmDebug & DBG_TRACE_HTTP)
fprintf(stderr, "pmhttpClientFetch: %s\n", url);
if (http_client_prepare(cp, url, body_buffer, body_length,
type_buffer, type_length) != 0)
return -1;
while (redirected <= cp->max_redirect) {
/* ensure we're connected to the server */
if ((sts = http_client_connect(cp)) < 0)
return sts;
/* make a GET request via the given URL */
if ((sts = http_client_get(cp)) < 0)
return sts;
if (sts == 1) /* server connection is lost */
continue;
/* parse, extract body, handle redirect */
if ((sts = http_client_response(cp)) < 0) {
if (sts == -EAGAIN) /* server closed */
continue;
if (sts == -EMLINK) { /* http redirect */
redirected++;
continue;
}
break; /* propogate errors */
}
break; /* successful exchange */
}
if (pmDebug & DBG_TRACE_HTTP)
fprintf(stderr, "pmhttpClientFetch sts=%d\n", sts);
return sts;
}
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 );
}
/*
* Send a copy of the message, wait for a reply, and return the reply.
*
* The "reply" should already be initialized.
*
* This properly handles the calling thread's being canceled.
*/
int
http_xml_send(struct http_client *client, struct in_addr ip,
u_int16_t port, int https, const char *urlpath, const char *username,
const char *password, const char *ptag, const char *pattrs,
const struct structs_type *ptype, const void *payload, int pflags,
const char *rtag, char **rattrsp, const char *rattrs_mtype,
const struct structs_type *rtype, void *reply, int rflags,
structs_xmllog_t *rlogger)
{
struct http_client_connection *cc;
struct http_request *req;
struct http_response *resp;
int ret = -1;
u_int code;
FILE *fp;
/* Get HTTP connection */
if ((cc = http_client_connect(client, ip, port, https)) == NULL) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"get HTTP client" _ inet_ntoa(ip) _ port);
return -1;
}
/* Push cleanup hook */
pthread_cleanup_push(http_xml_send_cleanup, cc);
/* Set up request */
req = http_client_get_request(cc);
if (http_request_set_method(req,
payload != NULL ? HTTP_METHOD_POST : HTTP_METHOD_GET) == -1) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"set method" _ inet_ntoa(ip) _ port);
goto fail;
}
if (http_request_set_path(req, urlpath) == -1) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"set path" _ inet_ntoa(ip) _ port);
goto fail;
}
if (http_request_set_header(req, 0, "Content-Type", "text/xml") == -1) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"set content-type" _ inet_ntoa(ip) _ port);
goto fail;
}
if (username != NULL && password != NULL) {
char *auth;
if ((auth = http_request_encode_basic_auth(TYPED_MEM_TEMP,
username, password)) == NULL) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"encode authorization" _ inet_ntoa(ip) _ port);
goto fail;
}
if (http_request_set_header(req, 0, "Authorization",
"Basic %s", auth) == -1) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"set authorization header" _ inet_ntoa(ip) _ port);
FREE(TYPED_MEM_TEMP, auth);
goto fail;
}
FREE(TYPED_MEM_TEMP, auth);
}
/* Write XML data to HTTP client output stream */
if (payload != NULL) {
if ((fp = http_request_get_output(req, 1)) == NULL) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"get output" _ inet_ntoa(ip) _ port);
goto fail;
}
if (structs_xml_output(ptype,
ptag, pattrs, payload, fp, NULL, pflags) == -1) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"write XML" _ inet_ntoa(ip) _ port);
goto fail;
}
}
/* Get response */
if ((resp = http_client_get_response(cc)) == NULL) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"get response" _ inet_ntoa(ip) _ port);
goto fail;
}
if ((code = http_response_get_code(resp)) != HTTP_STATUS_OK) {
alogf(LOG_ERR, "rec'd HTTP error code %d from"
"http%s://%s:%u%s: %s", code _ https ? "s" : "" _
inet_ntoa(ip) _ port _ urlpath _
http_response_status_msg(code));
goto fail;
}
/* Read XML reply from client input stream */
if ((fp = http_response_get_input(resp)) == NULL) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"get input" _ inet_ntoa(ip) _ port);
goto fail;
}
if (structs_xml_input(rtype, rtag, rattrsp,
rattrs_mtype, fp, reply, rflags, rlogger) == -1) {
alogf(LOG_ERR, "can't %s for %s:%u: %m",
"read XML reply" _ inet_ntoa(ip) _ port);
goto fail;
}
/* OK */
ret = 0;
fail:;
/* Done */
pthread_cleanup_pop(1);
return (ret);
}
