Return to repository.c CVS log

Up to [local] / src / usr.bin / cvs

Annotation of src/usr.bin/cvs/repository.c, Revision 1.4

1.4     ! joris       1: /*     $OpenBSD: repository.c,v 1.3 2006/06/02 19:10:24 david Exp $    */
1.1       joris       2: /*
                      3:  * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
                      4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the above
                      7:  * copyright notice and this permission notice appear in all copies.
                      8:  *
                      9:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     12:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     13:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     14:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     15:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     16:  */
                     17:
                     18: #include "includes.h"
                     19:
                     20: #include "cvs.h"
                     21: #include "file.h"
                     22: #include "log.h"
                     23: #include "repository.h"
                     24: #include "worklist.h"
                     25:
                     26: struct cvs_wklhead repo_locks;
                     27:
                     28: void
                     29: cvs_repository_unlock(const char *repo)
                     30: {
                     31:        int l;
                     32:        char fpath[MAXPATHLEN];
                     33:
                     34:        cvs_log(LP_TRACE, "cvs_repository_unlock(%s)", repo);
                     35:
                     36:        l = snprintf(fpath, sizeof(fpath), "%s/%s", repo, CVS_LOCK);
                     37:        if (l == -1 || l >= (int)sizeof(fpath))
                     38:                fatal("cvs_repository_unlock: overflow");
                     39:
                     40:        /* XXX - this ok? */
                     41:        cvs_worklist_run(&repo_locks, cvs_worklist_unlink);
                     42: }
                     43:
                     44: void
                     45: cvs_repository_lock(const char *repo)
                     46: {
                     47:        int l, i;
                     48:        struct stat st;
                     49:        char fpath[MAXPATHLEN];
                     50:        struct passwd *pw;
                     51:
                     52:        cvs_log(LP_TRACE, "cvs_repository_lock(%s)", repo);
                     53:
                     54:        l = snprintf(fpath, sizeof(fpath), "%s/%s", repo, CVS_LOCK);
                     55:        if (l == -1 || l >= (int)sizeof(fpath))
                     56:                fatal("cvs_repository_lock: overflow");
                     57:
                     58:        for (i = 0; i < CVS_LOCK_TRIES; i++) {
                     59:                if (cvs_quit)
                     60:                        fatal("received signal %d", sig_received);
                     61:
                     62:                if (stat(fpath, &st) == -1)
                     63:                        break;
                     64:
                     65:                if ((pw = getpwuid(st.st_uid)) == NULL)
                     66:                        fatal("cvs_repository_lock: %s", strerror(errno));
                     67:
                     68:                cvs_log(LP_NOTICE, "waiting for %s's lock in '%s'",
                     69:                    pw->pw_name, repo);
                     70:                sleep(CVS_LOCK_SLEEP);
                     71:        }
                     72:
                     73:        if (i == CVS_LOCK_TRIES)
                     74:                fatal("maximum wait time for lock inside '%s' reached", repo);
                     75:
                     76:        if ((i = open(fpath, O_WRONLY|O_CREAT|O_TRUNC, 0755)) < 0) {
                     77:                if (errno == EEXIST)
                     78:                        fatal("cvs_repository_lock: somebody beat us");
                     79:                else
1.3       david      80:                        fatal("cvs_repository_lock: %s: %s",
1.1       joris      81:                            fpath, strerror(errno));
                     82:        }
                     83:
                     84:        (void)close(i);
                     85:        cvs_worklist_add(fpath, &repo_locks);
                     86: }
                     87:
                     88: void
                     89: cvs_repository_getdir(const char *dir, const char *wdir,
1.2       joris      90:        struct cvs_flisthead *fl, struct cvs_flisthead *dl, int dodirs)
1.1       joris      91: {
                     92:        int l;
                     93:        DIR *dirp;
                     94:        struct dirent *dp;
                     95:        char *s, fpath[MAXPATHLEN];
                     96:
                     97:        if ((dirp = opendir(dir)) == NULL)
                     98:                fatal("cvs_repository_getdir: failed to open '%s'", dir);
                     99:
                    100:        while ((dp = readdir(dirp)) != NULL) {
                    101:                if (!strcmp(dp->d_name, ".") ||
                    102:                    !strcmp(dp->d_name, "..") ||
                    103:                    !strcmp(dp->d_name, "Attic") ||
                    104:                    !strcmp(dp->d_name, CVS_LOCK))
                    105:                        continue;
                    106:
                    107:                if (cvs_file_chkign(dp->d_name))
1.2       joris     108:                        continue;
                    109:
                    110:                if (dodirs == 0 && dp->d_type == DT_DIR)
1.1       joris     111:                        continue;
                    112:
                    113:                l = snprintf(fpath, sizeof(fpath), "%s/%s", wdir, dp->d_name);
                    114:                if (l == -1 || l >= (int)sizeof(fpath))
                    115:                        fatal("cvs_repository_getdir: overflow");
                    116:
                    117:                /*
                    118:                 * Anticipate the file type for sorting, we do not determine
                    119:                 * the final file type until we have the fd floating around.
                    120:                 */
                    121:                if (dp->d_type == DT_DIR) {
                    122:                        cvs_file_get(fpath, dl);
                    123:                } else if (dp->d_type == DT_REG) {
                    124:                        if ((s = strrchr(fpath, ',')) != NULL)
                    125:                                *s = '\0';
                    126:                        cvs_file_get(fpath, fl);
                    127:                }
                    128:        }
                    129:
                    130:        (void)closedir(dirp);
                    131: }