contrib/subversion/subversion/libsvn_subr/config_auth.c

   1 /*
   2  * config_auth.c :  authentication files in the user config area
   3  *
   4  * ====================================================================
   5  *    Licensed to the Apache Software Foundation (ASF) under one
   6  *    or more contributor license agreements.  See the NOTICE file
   7  *    distributed with this work for additional information
   8  *    regarding copyright ownership.  The ASF licenses this file
   9  *    to you under the Apache License, Version 2.0 (the
  10  *    "License"); you may not use this file except in compliance
  11  *    with the License.  You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  *    Unless required by applicable law or agreed to in writing,
  16  *    software distributed under the License is distributed on an
  17  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  18  *    KIND, either express or implied.  See the License for the
  19  *    specific language governing permissions and limitations
  20  *    under the License.
  21  * ====================================================================
  22  */
  23
  24
  25 \f
  26 #include "svn_dirent_uri.h"
  27 #include "svn_hash.h"
  28 #include "svn_io.h"
  29 #include "svn_pools.h"
  30 #include "config_impl.h"
  31
  32 #include "auth.h"
  33
  34 #include "svn_private_config.h"
  35
  36 #include "private/svn_auth_private.h"
  37
  38 svn_error_t *
  39 svn_auth__file_path(const char **path,
  40                     const char *cred_kind,
  41                     const char *realmstring,
  42                     const char *config_dir,
  43                     apr_pool_t *pool)
  44 {
  45   const char *authdir_path, *hexname;
  46   svn_checksum_t *checksum;
  47
  48   /* Construct the path to the directory containing the creds files,
  49      e.g. "~/.subversion/auth/svn.simple".  The last component is
  50      simply the cred_kind.  */
  51   SVN_ERR(svn_config_get_user_config_path(&authdir_path, config_dir,
  52                                           SVN_CONFIG__AUTH_SUBDIR, pool));
  53   if (authdir_path)
  54     {
  55       authdir_path = svn_dirent_join(authdir_path, cred_kind, pool);
  56
  57       /* Construct the basename of the creds file.  It's just the
  58          realmstring converted into an md5 hex string.  */
  59       SVN_ERR(svn_checksum(&checksum, svn_checksum_md5, realmstring,
  60                            strlen(realmstring), pool));
  61       hexname = svn_checksum_to_cstring(checksum, pool);
  62
  63       *path = svn_dirent_join(authdir_path, hexname, pool);
  64     }
  65   else
  66     *path = NULL;
  67
  68   return SVN_NO_ERROR;
  69 }
  70
  71
  72 svn_error_t *
  73 svn_config_read_auth_data(apr_hash_t **hash,
  74                           const char *cred_kind,
  75                           const char *realmstring,
  76                           const char *config_dir,
  77                           apr_pool_t *pool)
  78 {
  79   svn_node_kind_t kind;
  80   const char *auth_path;
  81
  82   *hash = NULL;
  83
  84   SVN_ERR(svn_auth__file_path(&auth_path, cred_kind, realmstring, config_dir,
  85                               pool));
  86   if (! auth_path)
  87     return SVN_NO_ERROR;
  88
  89   SVN_ERR(svn_io_check_path(auth_path, &kind, pool));
  90   if (kind == svn_node_file)
  91     {
  92       svn_stream_t *stream;
  93       svn_string_t *stored_realm;
  94
  95       SVN_ERR_W(svn_stream_open_readonly(&stream, auth_path, pool, pool),
  96                 _("Unable to open auth file for reading"));
  97
  98       *hash = apr_hash_make(pool);
  99
 100       SVN_ERR_W(svn_hash_read2(*hash, stream, SVN_HASH_TERMINATOR, pool),
 101                 apr_psprintf(pool, _("Error parsing '%s'"),
 102                              svn_dirent_local_style(auth_path, pool)));
 103
 104       stored_realm = svn_hash_gets(*hash, SVN_CONFIG_REALMSTRING_KEY);
 105
 106       if (!stored_realm || strcmp(stored_realm->data, realmstring) != 0)
 107         *hash = NULL; /* Hash collision, or somebody tampering with storage */
 108
 109       SVN_ERR(svn_stream_close(stream));
 110     }
 111
 112   return SVN_NO_ERROR;
 113 }
 114
 115
 116 svn_error_t *
 117 svn_config_write_auth_data(apr_hash_t *hash,
 118                            const char *cred_kind,
 119                            const char *realmstring,
 120                            const char *config_dir,
 121                            apr_pool_t *pool)
 122 {
 123   svn_stream_t *stream;
 124   const char *auth_path, *tmp_path;
 125
 126   SVN_ERR(svn_auth__file_path(&auth_path, cred_kind, realmstring, config_dir,
 127                               pool));
 128   if (! auth_path)
 129     return svn_error_create(SVN_ERR_NO_AUTH_FILE_PATH, NULL,
 130                             _("Unable to locate auth file"));
 131
 132   /* Add the realmstring to the hash, so programs (or users) can
 133      verify exactly which set of credentials this file holds.
 134      ### What if realmstring key is already in the hash? */
 135   svn_hash_sets(hash, SVN_CONFIG_REALMSTRING_KEY,
 136                 svn_string_create(realmstring, pool));
 137
 138   SVN_ERR_W(svn_stream_open_unique(&stream, &tmp_path,
 139                                    svn_dirent_dirname(auth_path, pool),
 140                                    svn_io_file_del_on_pool_cleanup,
 141                                    pool, pool),
 142             _("Unable to open auth file for writing"));
 143   SVN_ERR_W(svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR, pool),
 144             apr_psprintf(pool, _("Error writing hash to '%s'"),
 145                          svn_dirent_local_style(auth_path, pool)));
 146   SVN_ERR(svn_stream_close(stream));
 147   SVN_ERR(svn_io_file_rename(tmp_path, auth_path, pool));
 148
 149   /* To be nice, remove the realmstring from the hash again, just in
 150      case the caller wants their hash unchanged.
 151      ### Should we also do this when a write error occurs? */
 152   svn_hash_sets(hash, SVN_CONFIG_REALMSTRING_KEY, NULL);
 153
 154   return SVN_NO_ERROR;
 155 }
 156
 157
 158 svn_error_t *
 159 svn_config_walk_auth_data(const char *config_dir,
 160                           svn_config_auth_walk_func_t walk_func,
 161                           void *walk_baton,
 162                           apr_pool_t *scratch_pool)
 163 {
 164   int i;
 165   apr_pool_t *iterpool;
 166   svn_boolean_t finished = FALSE;
 167   const char *cred_kinds[] =
 168     {
 169       SVN_AUTH_CRED_SIMPLE,
 170       SVN_AUTH_CRED_USERNAME,
 171       SVN_AUTH_CRED_SSL_CLIENT_CERT,
 172       SVN_AUTH_CRED_SSL_CLIENT_CERT_PW,
 173       SVN_AUTH_CRED_SSL_SERVER_TRUST,
 174       NULL
 175     };
 176
 177   iterpool = svn_pool_create(scratch_pool);
 178   for (i = 0; cred_kinds[i]; i++)
 179     {
 180       const char *item_path;
 181       const char *dir_path;
 182       apr_hash_t *nodes;
 183       svn_error_t *err;
 184       apr_pool_t *itempool;
 185       apr_hash_index_t *hi;
 186
 187       svn_pool_clear(iterpool);
 188
 189       if (finished)
 190         break;
 191
 192       SVN_ERR(svn_auth__file_path(&item_path, cred_kinds[i], "!", config_dir,
 193                                   iterpool));
 194
 195       dir_path = svn_dirent_dirname(item_path, iterpool);
 196
 197       err = svn_io_get_dirents3(&nodes, dir_path, TRUE, iterpool, iterpool);
 198       if (err)
 199         {
 200           if (!APR_STATUS_IS_ENOENT(err->apr_err)
 201               && !SVN__APR_STATUS_IS_ENOTDIR(err->apr_err))
 202             return svn_error_trace(err);
 203
 204           svn_error_clear(err);
 205           continue;
 206         }
 207
 208       itempool = svn_pool_create(iterpool);
 209       for (hi = apr_hash_first(iterpool, nodes); hi; hi = apr_hash_next(hi))
 210         {
 211           svn_io_dirent2_t *dirent = apr_hash_this_val(hi);
 212           svn_stream_t *stream;
 213           apr_hash_t *creds_hash;
 214           const svn_string_t *realm;
 215           svn_boolean_t delete_file = FALSE;
 216
 217           if (finished)
 218             break;
 219
 220           if (dirent->kind != svn_node_file)
 221             continue;
 222
 223           svn_pool_clear(itempool);
 224
 225           item_path = svn_dirent_join(dir_path, apr_hash_this_key(hi),
 226                                       itempool);
 227
 228           err = svn_stream_open_readonly(&stream, item_path,
 229                                          itempool, itempool);
 230           if (err)
 231             {
 232               /* Ignore this file. There are no credentials in it anyway */
 233               svn_error_clear(err);
 234               continue;
 235             }
 236
 237           creds_hash = apr_hash_make(itempool);
 238           err = svn_hash_read2(creds_hash, stream,
 239                                SVN_HASH_TERMINATOR, itempool);
 240           err = svn_error_compose_create(err, svn_stream_close(stream));
 241           if (err)
 242             {
 243               /* Ignore this file. There are no credentials in it anyway */
 244               svn_error_clear(err);
 245               continue;
 246             }
 247
 248           realm = svn_hash_gets(creds_hash, SVN_CONFIG_REALMSTRING_KEY);
 249           if (! realm)
 250             continue; /* Not an auth file */
 251
 252           err = walk_func(&delete_file, walk_baton, cred_kinds[i],
 253                           realm->data, creds_hash, itempool);
 254           if (err && err->apr_err == SVN_ERR_CEASE_INVOCATION)
 255             {
 256               svn_error_clear(err);
 257               err = SVN_NO_ERROR;
 258               finished = TRUE;
 259             }
 260           SVN_ERR(err);
 261
 262           if (delete_file)
 263             {
 264               /* Delete the file on disk */
 265               SVN_ERR(svn_io_remove_file2(item_path, TRUE, itempool));
 266             }
 267         }
 268     }
 269
 270   svn_pool_destroy(iterpool);
 271   return SVN_NO_ERROR;
 272 }