static void wps_er_http_set_sel_reg_cb(void *ctx, struct http_client *c,
enum http_client_event event)
{
struct wps_er_ap *ap = ctx;
union wps_event_data data;
os_memset(&data, 0, sizeof(data));
switch (event) {
case HTTP_CLIENT_OK:
wpa_printf(MSG_DEBUG, "WPS ER: SetSelectedRegistrar OK");
data.set_sel_reg.state = WPS_ER_SET_SEL_REG_DONE;
data.set_sel_reg.uuid = ap->uuid;
break;
case HTTP_CLIENT_FAILED:
case HTTP_CLIENT_INVALID_REPLY:
case HTTP_CLIENT_TIMEOUT:
wpa_printf(MSG_DEBUG, "WPS ER: SetSelectedRegistrar failed");
data.set_sel_reg.state = WPS_ER_SET_SEL_REG_FAILED;
data.set_sel_reg.uuid = ap->uuid;
break;
}
http_client_free(ap->http);
ap->http = NULL;
if (data.set_sel_reg.uuid)
ap->er->wps->event_cb(ap->er->wps->cb_ctx,
WPS_EV_ER_SET_SELECTED_REGISTRAR, &data);
}
static void wps_er_http_get_dev_info_cb(void *ctx, struct http_client *c,
enum http_client_event event)
{
struct wps_er_ap *ap = ctx;
struct wpabuf *reply;
char *dev_info = NULL;
switch (event) {
case HTTP_CLIENT_OK:
wpa_printf(MSG_DEBUG, "WPS ER: GetDeviceInfo OK");
reply = http_client_get_body(c);
if (reply == NULL)
break;
dev_info = os_zalloc(wpabuf_len(reply) + 1);
if (dev_info == NULL)
break;
os_memcpy(dev_info, wpabuf_head(reply), wpabuf_len(reply));
break;
case HTTP_CLIENT_FAILED:
case HTTP_CLIENT_INVALID_REPLY:
case HTTP_CLIENT_TIMEOUT:
wpa_printf(MSG_DEBUG, "WPS ER: GetDeviceInfo failed");
break;
}
http_client_free(ap->http);
ap->http = NULL;
if (dev_info) {
wps_er_ap_learn(ap, dev_info);
os_free(dev_info);
}
}
static void wps_er_ap_free(struct wps_er_ap *ap)
{
http_client_free(ap->http);
ap->http = NULL;
os_free(ap->location);
os_free(ap->friendly_name);
os_free(ap->manufacturer);
os_free(ap->manufacturer_url);
os_free(ap->model_description);
os_free(ap->model_name);
os_free(ap->model_number);
os_free(ap->model_url);
os_free(ap->serial_number);
os_free(ap->udn);
os_free(ap->upc);
os_free(ap->scpd_url);
os_free(ap->control_url);
os_free(ap->event_sub_url);
os_free(ap->ap_settings);
os_free(ap);
}
static void wps_er_http_unsubscribe_cb(void *ctx, struct http_client *c,
enum http_client_event event)
{
struct wps_er_ap *ap = ctx;
switch (event) {
case HTTP_CLIENT_OK:
wpa_printf(MSG_DEBUG, "WPS ER: Unsubscribed from events");
ap->subscribed = 0;
break;
case HTTP_CLIENT_FAILED:
case HTTP_CLIENT_INVALID_REPLY:
case HTTP_CLIENT_TIMEOUT:
wpa_printf(MSG_DEBUG, "WPS ER: Failed to unsubscribe from "
"events");
break;
}
http_client_free(ap->http);
ap->http = NULL;
/*
* Need to get rid of the AP entry regardless of whether we managed to
* unsubscribe cleanly or not.
*/
wps_er_ap_unsubscribed(ap->er, ap);
}
static void wps_er_http_dev_desc_cb(void *ctx, struct http_client *c,
enum http_client_event event)
{
struct wps_er_ap *ap = ctx;
struct wpabuf *reply;
int ok = 0;
switch (event) {
case HTTP_CLIENT_OK:
reply = http_client_get_body(c);
if (reply == NULL)
break;
wps_er_parse_device_description(ap, reply);
ok = 1;
break;
case HTTP_CLIENT_FAILED:
case HTTP_CLIENT_INVALID_REPLY:
case HTTP_CLIENT_TIMEOUT:
wpa_printf(MSG_DEBUG, "WPS ER: Failed to fetch device info");
break;
}
http_client_free(ap->http);
ap->http = NULL;
if (ok)
wps_er_get_device_info(ap);
}
/* event_clean -- clean sockets etc. of event
* Leaves data, retry count etc. alone.
*/
static void event_clean(struct wps_event_ *e)
{
if (e->s->current_event == e)
e->s->current_event = NULL;
http_client_free(e->http_event);
e->http_event = NULL;
}
static int
post_to_interface (char *data, size_t data_len) {
if (0 > http_client_pool_post_request2(&client_pool, eserv.server, eserv.port, eserv.hostname, data, data_len, "%s/%s", eserv.context, eserv.hostname)) {
return LOGGER_ERROR("failed to send request to %s", eserv.hostname), -1;
}
yield();
struct http_client_context *rcctx = http_client_get_last_context();
if (rcctx->http_status_code != 201) {
++failure;
http_client_free(rcctx);
return LOGGER_ERROR("request failed with code %d", rcctx->http_status_code), -1;
}
++success;
return http_client_free(rcctx), 0;
}
void
worker_can_read(int fd, short event, void *p) {
struct http_client *c = p;
int ret, nparsed;
(void)fd;
(void)event;
ret = http_client_read(c);
if(ret <= 0) {
if((client_error_t)ret == CLIENT_DISCONNECTED) {
return;
} else if (c->failed_alloc || (client_error_t)ret == CLIENT_OOM) {
slog(c->w->s, WEBDIS_DEBUG, "503", 3);
http_send_error(c, 503, "Service Unavailable");
return;
}
}
if(c->is_websocket) {
/* Got websocket data */
ws_add_data(c);
} else {
/* run parser */
nparsed = http_client_execute(c);
if(c->failed_alloc) {
slog(c->w->s, WEBDIS_DEBUG, "503", 3);
http_send_error(c, 503, "Service Unavailable");
} else if(c->is_websocket) {
/* we need to use the remaining (unparsed) data as the body. */
if(nparsed < ret) {
http_client_add_to_body(c, c->buffer + nparsed + 1, c->sz - nparsed - 1);
ws_handshake_reply(c);
} else {
c->broken = 1;
}
free(c->buffer);
c->buffer = NULL;
c->sz = 0;
} else if(nparsed != ret) {
slog(c->w->s, WEBDIS_DEBUG, "400", 3);
http_send_error(c, 400, "Bad Request");
} else if(c->request_sz > c->s->cfg->http_max_request_size) {
slog(c->w->s, WEBDIS_DEBUG, "413", 3);
http_send_error(c, 413, "Request Entity Too Large");
}
}
if(c->broken) { /* terminate client */
http_client_free(c);
} else {
/* start monitoring input again */
worker_monitor_input(c);
}
}
struct http_client * http_client_addr(struct sockaddr_in *dst,
struct wpabuf *req, size_t max_response,
void (*cb)(void *ctx,
struct http_client *c,
enum http_client_event event),
void *cb_ctx)
{
struct http_client *c;
c = os_zalloc(sizeof(*c));
if (c == NULL)
return NULL;
c->sd = -1;
c->dst = *dst;
c->max_response = max_response;
c->cb = cb;
c->cb_ctx = cb_ctx;
c->sd = socket(AF_INET, SOCK_STREAM, 0);
if (c->sd < 0)
goto fail;
if (fcntl(c->sd, F_SETFL, O_NONBLOCK) != 0) {
wpa_printf(MSG_DEBUG, "HTTP: fnctl(O_NONBLOCK) failed: %s",
strerror(errno));
goto fail;
}
if (connect(c->sd, (struct sockaddr *) dst, sizeof(*dst))) {
if (errno != EINPROGRESS) {
wpa_printf(MSG_DEBUG, "HTTP: Failed to connect: %s",
strerror(errno));
goto fail;
}
/*
* Continue connecting in the background; eloop will call us
* once the connection is ready (or failed).
*/
}
if (eloop_register_sock(c->sd, EVENT_TYPE_WRITE, http_client_tx_ready,
c, NULL) ||
eloop_register_timeout(HTTP_CLIENT_TIMEOUT_SEC, 0,
http_client_timeout, c, NULL))
goto fail;
c->req = req;
return c;
fail:
http_client_free(c);
return NULL;
}
int http_client_pool_post_request_send(struct http_client_context *context, struct vmbuf *post_data) {
size_t size = vmbuf_wlocpos(post_data);
vmbuf_sprintf(&context->request, "\r\nContent-Length: %zu\r\n\r\n", size);
// TODO: use writev instead of copying
vmbuf_memcpy(&context->request, vmbuf_data(post_data), size);
if (0 > http_client_send_request(context)) {
http_client_free(context);
return -1;
}
return 0;
}
static void
pairing_fail_cb(struct http_connection *c, void *arg)
{
struct remote_info *ri;
ri = (struct remote_info *)arg;
DPRINTF(E_LOG, L_REMOTE, "HTTP client failure while pairing with %s\n", ri->pi.name);
/* free_cb takes care of ri */
http_client_free(c);
}
static void wps_er_sta_free(struct wps_er_sta *sta)
{
wps_er_sta_event(sta->ap->er->wps, sta, WPS_EV_ER_ENROLLEE_REMOVE);
if (sta->wps)
wps_deinit(sta->wps);
os_free(sta->manufacturer);
os_free(sta->model_name);
os_free(sta->model_number);
os_free(sta->serial_number);
os_free(sta->dev_name);
http_client_free(sta->http);
eloop_cancel_timeout(wps_er_sta_timeout, sta, NULL);
os_free(sta->cred);
os_free(sta);
}
/**
* @zobject: swoole_http_client_coro object
*/
static void http_client_coro_onClose(swClient *cli)
{
#if PHP_MAJOR_VERSION < 7
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
#endif
zval *zobject = cli->object;
if (!cli->released)
{
http_client_free(zobject TSRMLS_CC);
}
#if PHP_MAJOR_VERSION < 7
sw_zval_ptr_dtor(&zobject);
#endif
return;
}
int http_client_pool_get_request(struct http_client_pool *http_client_pool, struct in_addr addr, uint16_t port, const char *hostname, const char *format, ...) {
struct http_client_context *cctx = http_client_pool_create_client(http_client_pool, addr, port, NULL);
if (NULL == cctx)
return -1;
vmbuf_strcpy(&cctx->request, "GET ");
va_list ap;
va_start(ap, format);
vmbuf_vsprintf(&cctx->request, format, ap);
va_end(ap);
vmbuf_sprintf(&cctx->request, " HTTP/1.1\r\nHost: %s\r\n\r\n", hostname);
if (0 > http_client_send_request(cctx)) {
http_client_free(http_client_pool, cctx);
return -1;
}
return 0;
}
/**
* @zobject: swoole_http_client object
*/
static void http_client_coro_onError(swClient *cli)
{
#if PHP_MAJOR_VERSION < 7
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
#endif
zval *zdata;
zval *retval = NULL;
SW_MAKE_STD_ZVAL(zdata);
//return false
ZVAL_BOOL(zdata, 0);
zval *zobject = cli->object;
php_context *sw_current_context = swoole_get_property(zobject, 1);
zend_update_property_long(swoole_http_client_coro_class_entry_ptr, zobject, ZEND_STRL("errCode"), SwooleG.error TSRMLS_CC);
if (cli->timeout_id > 0)
{
php_swoole_clear_timer_coro(cli->timeout_id TSRMLS_CC);
cli->timeout_id=0;
}
if (!cli->released)
{
http_client_free(zobject TSRMLS_CC);
}
swoole_set_object(zobject, NULL);
http_client_property *hcc = swoole_get_property(zobject, 0);
if(hcc->defer && hcc->defer_status != HTTP_CLIENT_STATE_DEFER_WAIT){
hcc->defer_status = HTTP_CLIENT_STATE_DEFER_DONE;
hcc->defer_result = 0;
goto free_zdata;
}
hcc->defer_status = HTTP_CLIENT_STATE_DEFER_INIT;
int ret = coro_resume(sw_current_context, zdata, &retval);
if (ret > 0)
{
goto free_zdata;
}
if (retval != NULL)
{
sw_zval_ptr_dtor(&retval);
}
free_zdata:
sw_zval_ptr_dtor(&zdata);
}
static void wps_er_http_put_message_cb(void *ctx, struct http_client *c,
enum http_client_event event)
{
struct wps_er_ap *ap = ctx;
struct wpabuf *reply;
char *msg = NULL;
switch (event) {
case HTTP_CLIENT_OK:
wpa_printf(MSG_DEBUG, "WPS ER: PutMessage OK");
reply = http_client_get_body(c);
if (reply == NULL)
break;
msg = os_zalloc(wpabuf_len(reply) + 1);
if (msg == NULL)
break;
os_memcpy(msg, wpabuf_head(reply), wpabuf_len(reply));
break;
case HTTP_CLIENT_FAILED:
case HTTP_CLIENT_INVALID_REPLY:
case HTTP_CLIENT_TIMEOUT:
wpa_printf(MSG_DEBUG, "WPS ER: PutMessage failed");
if (ap->wps) {
wps_deinit(ap->wps);
ap->wps = NULL;
}
break;
}
http_client_free(ap->http);
ap->http = NULL;
if (msg) {
struct wpabuf *buf;
enum http_reply_code ret;
buf = xml_get_base64_item(msg, "NewOutMessage", &ret);
os_free(msg);
if (buf == NULL) {
wpa_printf(MSG_DEBUG, "WPS ER: Could not extract "
"NewOutMessage from PutMessage response");
wps_deinit(ap->wps);
ap->wps = NULL;
return;
}
wps_er_ap_process(ap, buf);
wpabuf_free(buf);
}
}
static void http_client_coro_onTimeout(php_context *ctx)
{
#if PHP_MAJOR_VERSION < 7
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
#endif
zval *zdata;
zval *retval = NULL;
SW_MAKE_STD_ZVAL(zdata);
ZVAL_BOOL(zdata, 0); //return false
#if PHP_MAJOR_VERSION < 7
zval *zobject = (zval *)ctx->coro_params;
#else
zval _zobject = ctx->coro_params;
zval *zobject = & _zobject;
#endif
//define time out RETURN ERROR 110
zend_update_property_long(swoole_http_client_coro_class_entry_ptr, zobject, ZEND_STRL("errCode"), 110 TSRMLS_CC);
http_client *http = swoole_get_object(zobject);
http->cli->released = 1;
http_client_free(zobject TSRMLS_CC);
swoole_set_object(zobject, NULL);
http_client_property *hcc = swoole_get_property(zobject, 0);
if(hcc->defer && hcc->defer_status != HTTP_CLIENT_STATE_DEFER_WAIT){
hcc->defer_status = HTTP_CLIENT_STATE_DEFER_DONE;
hcc->defer_result = 0;
goto free_zdata;
}
hcc->defer_status = HTTP_CLIENT_STATE_DEFER_INIT;
int ret = coro_resume(ctx, zdata, &retval);
if (ret > 0)
{
goto free_zdata;
}
if (retval != NULL)
{
sw_zval_ptr_dtor(&retval);
}
free_zdata:
sw_zval_ptr_dtor(&zdata);
}
static void wps_er_http_put_wlan_response_cb(void *ctx, struct http_client *c,
enum http_client_event event)
{
struct wps_er_sta *sta = ctx;
switch (event) {
case HTTP_CLIENT_OK:
wpa_printf(MSG_DEBUG, "WPS ER: PutWLANResponse OK");
break;
case HTTP_CLIENT_FAILED:
case HTTP_CLIENT_INVALID_REPLY:
case HTTP_CLIENT_TIMEOUT:
wpa_printf(MSG_DEBUG, "WPS ER: PutWLANResponse failed");
break;
}
http_client_free(sta->http);
sta->http = NULL;
}
int
http_client_read(struct http_client *c) {
char buffer[4096];
int ret;
ret = read(c->fd, buffer, sizeof(buffer));
if(ret <= 0) {
/* broken link, free buffer and client object */
/* disconnect pub/sub client if there is one. */
if(c->pub_sub && c->pub_sub->ac) {
struct cmd *cmd = c->pub_sub;
/* disconnect from all channels */
redisAsyncDisconnect(c->pub_sub->ac);
// c->pub_sub might be already cleared by an event handler in redisAsyncDisconnect
cmd->ac = NULL;
c->pub_sub = NULL;
/* delete command object */
cmd_free(cmd);
}
close(c->fd);
http_client_free(c);
return (int)CLIENT_DISCONNECTED;
}
/* save what we've just read */
c->buffer = realloc(c->buffer, c->sz + ret);
if(!c->buffer) {
return (int)CLIENT_OOM;
}
memcpy(c->buffer + c->sz, buffer, ret);
c->sz += ret;
/* keep track of total sent */
c->request_sz += ret;
return ret;
}
static void wps_er_ap_remove_entry(struct wps_er *er, struct wps_er_ap *ap)
{
wpa_printf(MSG_DEBUG, "WPS ER: Removing AP entry for %s (%s)",
inet_ntoa(ap->addr), ap->location);
eloop_cancel_timeout(wps_er_ap_timeout, er, ap);
wps_er_sta_remove_all(ap);
wps_er_ap_event(er->wps, ap, WPS_EV_ER_AP_REMOVE);
http_client_free(ap->http);
ap->http = NULL;
if (ap->wps) {
wps_deinit(ap->wps);
ap->wps = NULL;
}
dl_list_del(&ap->list);
if (ap->subscribed) {
dl_list_add(&er->ap_unsubscribing, &ap->list);
wps_er_ap_unsubscribe(er, ap);
} else
wps_er_ap_free(ap);
}
static void wps_er_http_subscribe_cb(void *ctx, struct http_client *c,
enum http_client_event event)
{
struct wps_er_ap *ap = ctx;
switch (event) {
case HTTP_CLIENT_OK:
wpa_printf(MSG_DEBUG, "WPS ER: Subscribed to events");
ap->subscribed = 1;
wps_er_get_sid(ap, http_client_get_hdr_line(c, "SID"));
wps_er_ap_use_cached_settings(ap->er, ap);
wps_er_ap_event(ap->er->wps, ap, WPS_EV_ER_AP_ADD);
break;
case HTTP_CLIENT_FAILED:
case HTTP_CLIENT_INVALID_REPLY:
case HTTP_CLIENT_TIMEOUT:
wpa_printf(MSG_DEBUG, "WPS ER: Failed to subscribe to events");
break;
}
http_client_free(ap->http);
ap->http = NULL;
}
static int
http_client_pool_post_request2(
struct http_client_pool *http_client_pool,
struct in_addr addr, uint16_t port, const char *hostname,
const char *data, size_t size_of_data, const char *format, ...) {
struct http_client_context *cctx = http_client_pool_create_client2(http_client_pool, addr, port, hostname, NULL);
if (NULL == cctx)
return -1;
vmbuf_reset(&cctx->request);
vmbuf_strcpy(&cctx->request, "POST ");
va_list ap;
va_start(ap, format);
vmbuf_vsprintf(&cctx->request, format, ap);
va_end(ap);
vmbuf_sprintf(&cctx->request, " HTTP/1.1\r\nHost: %s\r\nContent-Type: application/json\r\nContent-Length: %zu\r\n\r\n", hostname, size_of_data);
vmbuf_memcpy(&cctx->request, data, size_of_data);
vmbuf_chrcpy(&cctx->request, '\0');
if (0 > http_client_send_request(cctx))
return http_client_free(cctx), -1;
return 0;
}
int
http_client_read(struct http_client *c) {
char buffer[4096];
int ret;
ret = read(c->fd, buffer, sizeof(buffer));
if(ret <= 0) {
/* broken link, free buffer and client object */
/* disconnect pub/sub client if there is one. */
if(c->pub_sub && c->pub_sub->ac) {
struct cmd *cmd = c->pub_sub;
/* disconnect from all channels */
redisAsyncDisconnect(c->pub_sub->ac);
if(c->pub_sub) c->pub_sub->ac = NULL;
c->pub_sub = NULL;
/* delete command object */
cmd_free(cmd);
}
close(c->fd);
http_client_free(c);
return -1;
}
/* save what we've just read */
c->buffer = realloc(c->buffer, c->sz + ret);
memcpy(c->buffer + c->sz, buffer, ret);
c->sz += ret;
return ret;
}
/* Queue: pairing */
static int
send_pairing_request(struct remote_info *ri, char *req_uri, int family)
{
struct http_connection *c;
struct http_request *req;
char *address;
unsigned short port;
int ret;
switch (family)
{
case AF_INET:
if (!ri->v4_address)
return -1;
address = ri->v4_address;
port = ri->v4_port;
break;
case AF_INET6:
if (!ri->v6_address)
return -1;
address = ri->v6_address;
port = ri->v6_port;
break;
default:
return -1;
}
c = http_client_new(L_REMOTE, address, port, pairing_fail_cb, pairing_free_cb, ri);
if (!c)
{
DPRINTF(E_LOG, L_REMOTE, "Could not create HTTP client for pairing with %s\n", ri->pi.name);
return -1;
}
req = http_client_request_new(HTTP_GET, P_VER_1_1, req_uri, pairing_request_cb);
if (!req)
{
DPRINTF(E_WARN, L_REMOTE, "Could not create HTTP request for pairing\n");
goto request_fail;
}
ret = http_request_add_header(req, "Connection", "close");
if (ret < 0)
DPRINTF(E_WARN, L_REMOTE, "Could not add Connection: close header\n");
ret = http_client_request_run(c, req);
if (ret < 0)
{
DPRINTF(E_WARN, L_REMOTE, "Could not run pairing request\n");
goto run_fail;
}
return 0;
run_fail:
http_request_free(req);
request_fail:
http_client_free(c);
return -1;
}
/* Queue: pairing */
static int
pairing_request_cb(struct http_connection *c, struct http_request *req, struct http_response *r, void *arg)
{
struct remote_info *ri;
struct evbuffer *body;
char guid[17];
const char *reason;
uint8_t *response;
size_t bodylen;
int code;
int len;
int i;
int ret;
ri = (struct remote_info *)arg;
code = http_response_get_status(r, &reason);
if (code != HTTP_OK)
{
DPRINTF(E_LOG, L_REMOTE, "Pairing failed with Remote %s/%s, HTTP response code %d (%s)\n", ri->pi.remote_id, ri->pi.name, code, reason);
goto cleanup;
}
body = http_response_get_body(r);
if (!body || (EVBUFFER_LENGTH(body) < 8))
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: pairing response too short\n", ri->pi.remote_id, ri->pi.name);
goto cleanup;
}
bodylen = EVBUFFER_LENGTH(body);
response = EVBUFFER_DATA(body);
if ((response[0] != 'c') || (response[1] != 'm') || (response[2] != 'p') || (response[3] != 'a'))
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: unknown pairing response, expected cmpa\n", ri->pi.remote_id, ri->pi.name);
goto cleanup;
}
len = (response[4] << 24) | (response[5] << 16) | (response[6] << 8) | (response[7]);
if (bodylen < 8 + len)
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: pairing response truncated (got %d expected %d)\n",
ri->pi.remote_id, ri->pi.name, (int)bodylen, len + 8);
goto cleanup;
}
response += 8;
for (; len > 0; len--, response++)
{
if ((response[0] != 'c') || (response[1] != 'm') || (response[2] != 'p') || (response[3] != 'g'))
continue;
else
{
len -= 8;
response += 8;
break;
}
}
if (len < 8)
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: cmpg truncated in pairing response\n", ri->pi.remote_id, ri->pi.name);
goto cleanup;
}
for (i = 0; i < 8; i++)
sprintf(guid + (2 * i), "%02X", response[i]);
ri->pi.guid = strdup(guid);
DPRINTF(E_INFO, L_REMOTE, "Pairing succeeded with Remote '%s' (id %s), GUID: %s\n", ri->pi.name, ri->pi.remote_id, guid);
ret = db_pool_get();
if (ret < 0)
{
DPRINTF(E_LOG, L_REMOTE, "Could not acquire database connection; cannot register pairing with %s\n", ri->pi.name);
goto cleanup;
}
ret = db_pairing_add(&ri->pi);
db_pool_release();
if (ret < 0)
{
DPRINTF(E_LOG, L_REMOTE, "Failed to register pairing!\n");
goto cleanup;
}
cleanup:
http_request_free(req);
http_client_free(c);
return 0;
}
