subversion/libsvn_ra_serf/util.c

91 save_error(svn_ra_serf__session_t *session,
94   if (err || session->pending_error)
96       session->pending_error = svn_error_compose_create(
97                                   session->pending_error,
99       return session->pending_error->apr_err;
108 construct_realm(svn_ra_serf__session_t *session,
114   if (session->session_url.port_str)
116       port = session->session_url.port;
120       port = apr_uri_port_of_scheme(session->session_url.scheme);
124                        session->session_url.scheme,
125                        session->session_url.hostname,
239           svn_string_create(conn->session->session_url.hostname, scratch_pool);
319       svn_auth_set_parameter(conn->session->auth_baton,
323       svn_auth_set_parameter(conn->session->auth_baton,
333                                        conn->session->auth_baton,
336       svn_auth_set_parameter(conn->session->auth_baton,
339       svn_auth_set_parameter(conn->session->auth_baton,
366   svn_auth_set_parameter(conn->session->auth_baton,
370   svn_auth_set_parameter(conn->session->auth_baton,
374   realmstring = construct_realm(conn->session, conn->session->pool);
379                                      conn->session->auth_baton,
400   svn_auth_set_parameter(conn->session->auth_baton,
444   svn_ra_serf__session_t *session = conn->session;
448   subpool = svn_pool_create(session->pool);
452   return save_error(session, err);
499       conn->session->http10 = FALSE;
500       conn->session->http20 = TRUE;
501       conn->session->using_chunked_requests = TRUE;
502       conn->session->detect_chunking = FALSE;
525   *read_bkt = serf_context_bucket_socket_create(conn->session->context,
528   if (conn->session->using_ssl)
538                                 conn->session->session_url.hostname);
542                                             conn, conn->session->pool);
545                                             conn, conn->session->pool);
551           if (conn->session->trust_default_ca)
556           if (conn->session->ssl_authorities)
558               SVN_ERR(load_authorities(conn, conn->session->ssl_authorities,
559                                        conn->session->pool));
596   svn_ra_serf__session_t *session = conn->session;
604   return save_error(session, err);
654   if (conn->session->using_ssl)
671   (void) save_error(ra_conn->session, err);
682     svn_ra_serf__session_t *session = conn->session;
688     realm = construct_realm(session, session->pool);
696                                            session->auth_baton,
703                                           session->pool));
721   svn_ra_serf__session_t *session = conn->session;
724   err = svn_error_trace(handle_client_cert(data, cert_path, session->pool));
726   return save_error(session, err);
737     svn_ra_serf__session_t *session = conn->session;
748                                            session->auth_baton,
777   svn_ra_serf__session_t *session = conn->session;
783                                               session->pool));
785   return save_error(session, err);
813                svn_ra_serf__session_t *session,
824   svn_boolean_t set_CL = session->http10 || !session->using_chunked_requests;
867   serf_bucket_headers_setn(*hdrs_bkt, "User-Agent", session->useragent);
874   if (session->http10)
1025   err = svn_ra_serf__context_run_wait(&handler->done, handler->session,
1191   svn_ra_serf__session_t *session = handler->session;
1199          credentials during this session OR if the last time we asked
1200          session->auth_state wasn't set (eg. if the credentials provider was
1202       if (!session->auth_state)
1205                                            &session->auth_state,
1208                                            session->auth_baton,
1209                                            session->pool);
1214                                           session->auth_state,
1215                                           session->pool);
1220           (void) save_error(session, err);
1224       session->auth_attempts++;
1226       if (!creds || session->auth_attempts > 4)
1229           (void) save_error(session,
1243       *username = apr_pstrdup(pool, session->proxy_username);
1244       *password = apr_pstrdup(pool, session->proxy_password);
1246       session->proxy_auth_attempts++;
1248       if (!session->proxy_username || session->proxy_auth_attempts > 4)
1251           (void) save_error(session,
1341         handler->session->http10 = FALSE;
1344         handler->session->http20 = TRUE;
1398                                             handler->session->session_url_str,
1406       SVN_ERR(svn_auth_save_credentials(handler->session->auth_state,
1407                                         handler->session->pool));
1408       handler->session->auth_attempts = 0;
1409       handler->session->auth_state = NULL;
1455                                         handler->session->pool));
1463                                         handler->session->pool));
1509    errors in handler->session->pending_error if appropriate. */
1527   outer_status = save_error(handler->session, err);
1534       svn_ra_serf__session_t *sess = handler->session;
1539       /* We use a cached handler->session here to allow handler to free the
1546            && handler->session->pending_error)
1593   else if (handler->session->using_compression != svn_tristate_false)
1604                          handler->session, handler->method, handler->path,
1653   return save_error(handler->session, err);
1689                           svn_ra_serf__session_t *session,
1697   if (session->vcc_url && session->repos_root_str)
1699       *vcc_url = session->vcc_url;
1703   path = session->session_url.path;
1712       err = svn_ra_serf__fetch_node_props(&props, session,
1759   if (!session->vcc_url)
1761       session->vcc_url = apr_pstrdup(session->pool, *vcc_url);
1765   if (!session->repos_root_str)
1775       session->repos_root = session->session_url;
1776       session->repos_root.path =
1777         (char *)svn_fspath__canonicalize(url_buf->data, session->pool);
1778       session->repos_root_str =
1779         svn_urlpath__canonicalize(apr_uri_unparse(session->pool,
1780                                                   &session->repos_root, 0),
1781                                   session->pool);
1785   if (!session->uuid)
1787       session->uuid = apr_pstrdup(session->pool, uuid);
1796                                svn_ra_serf__session_t *session,
1801   if (! session->repos_root.path)
1807       assert(! SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session));
1810          promises to populate the session's root-url cache, and that's
1812       SVN_ERR(svn_ra_serf__discover_vcc(&vcc_url, session,
1816   decoded_root = svn_path_uri_decode(session->repos_root.path, pool);
1825                              svn_ra_serf__session_t *session,
1830   if (SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session))
1831     *report_target = apr_pstrdup(pool, session->me_resource);
1835     SVN_ERR(svn_ra_serf__discover_vcc(report_target, session, pool));
1940   svn_ra_serf__session_t *session = ra_session->priv;
1942   session->shim_callbacks = callbacks;
1998 svn_ra_serf__create_handler(svn_ra_serf__session_t *session,
2009   handler->session = session;
2010   handler->conn = session->conns[0];
2048                                            svn_ra_serf__session_t *session)
2050   if (session->using_compression == svn_tristate_false)
2057   else if (session->using_compression == svn_tristate_unknown &&
2058            svn_ra_serf__is_low_latency_connection(session))
2082 svn_ra_serf__is_low_latency_connection(svn_ra_serf__session_t *session)
2084   return session->conn_latency >= 0 &&
2085          session->conn_latency < apr_time_from_msec(5);
2090                               svn_ra_serf__session_t *session,
2097   if (session->supports_deadprop_count != svn_tristate_false