/*      $NetBSD: subr.c,v 1.51 2012/11/04 22:46:08 christos Exp $        */

/*
* Copyright (c) 2006  Antti Kantee.  All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: subr.c,v 1.51 2012/11/04 22:46:08 christos Exp $");
#endif /* !lint */

#include <stdio.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <puffs.h>
#include <stdlib.h>
#include <util.h>

#include "psshfs.h"
#include "sftp_proto.h"

static void
freedircache(struct psshfs_dir *base, size_t count)
{
       size_t i;

       for (i = 0; i < count; i++) {
               free(base[i].entryname);
               base[i].entryname = NULL;
       }

       free(base);
}

#define ENTRYCHUNK 16
static void
allocdirs(struct psshfs_node *psn)
{
       size_t oldtot = psn->denttot;

       psn->denttot += ENTRYCHUNK;
       psn->dir = erealloc(psn->dir,
           psn->denttot * sizeof(struct psshfs_dir));
       memset(psn->dir + oldtot, 0, ENTRYCHUNK * sizeof(struct psshfs_dir));
}

static void
setpnva(struct puffs_usermount *pu, struct puffs_node *pn,
       const struct vattr *vap)
{
       struct psshfs_ctx *pctx = puffs_getspecific(pu);
       struct psshfs_node *psn = pn->pn_data;
       struct vattr modva;

       /*
        * Check if the file was modified from below us.
        * If so, invalidate page cache.  This is the only
        * sensible place we can do this in.
        */
       if (pn->pn_va.va_mtime.tv_sec != PUFFS_VNOVAL)
               if (pn->pn_va.va_mtime.tv_sec != vap->va_mtime.tv_sec
                   && pn->pn_va.va_type == VREG)
                       puffs_inval_pagecache_node(pu, pn);

       modva = *vap;
       if (pctx->domangleuid && modva.va_uid == pctx->mangleuid)
               modva.va_uid = pctx->myuid;
       if (pctx->domanglegid && modva.va_gid == pctx->manglegid)
               modva.va_gid = pctx->mygid;

       puffs_setvattr(&pn->pn_va, &modva);
       psn->attrread = time(NULL);
}

struct psshfs_dir *
lookup(struct psshfs_dir *bdir, size_t ndir, const char *name)
{
       struct psshfs_dir *test;
       size_t i;

       for (i = 0; i < ndir; i++) {
               test = &bdir[i];
               if (test->valid != 1)
                       continue;
               if (strcmp(test->entryname, name) == 0)
                       return test;
       }

       return NULL;
}

static struct psshfs_dir *
lookup_by_entry(struct psshfs_dir *bdir, size_t ndir, struct puffs_node *entry)
{
       struct psshfs_dir *test;
       size_t i;

       for (i = 0; i < ndir; i++) {
               test = &bdir[i];
               if (test->valid != 1)
                       continue;
               if (test->entry == entry)
                       return test;
       }

       return NULL;
}


void
closehandles(struct puffs_usermount *pu, struct psshfs_node *psn, int which)
{
       struct psshfs_ctx *pctx = puffs_getspecific(pu);
       struct puffs_framebuf *pb1, *pb2;
       uint32_t reqid;

       if (psn->fhand_r && (which & HANDLE_READ)) {
               assert(psn->lazyopen_r == NULL);

               pb1 = psbuf_makeout();
               reqid = NEXTREQ(pctx);
               psbuf_req_data(pb1, SSH_FXP_CLOSE, reqid,
                   psn->fhand_r, psn->fhand_r_len);
               puffs_framev_enqueue_justsend(pu, pctx->sshfd_data, pb1, 1, 0);
               free(psn->fhand_r);
               psn->fhand_r = NULL;
       }

       if (psn->fhand_w && (which & HANDLE_WRITE)) {
               assert(psn->lazyopen_w == NULL);

               pb2 = psbuf_makeout();
               reqid = NEXTREQ(pctx);
               psbuf_req_data(pb2, SSH_FXP_CLOSE, reqid,
                   psn->fhand_w, psn->fhand_w_len);
               puffs_framev_enqueue_justsend(pu, pctx->sshfd_data, pb2, 1, 0);
               free(psn->fhand_w);
               psn->fhand_w = NULL;
       }

       psn->stat |= PSN_HANDLECLOSE;
}

void
lazyopen_rresp(struct puffs_usermount *pu, struct puffs_framebuf *pb,
       void *arg, int error)
{
       struct psshfs_node *psn = arg;

       /* XXX: this is not enough */
       if (psn->stat & PSN_RECLAIMED) {
               error = ENOENT;
               goto moreout;
       }
       if (error)
               goto out;

       error = psbuf_expect_handle(pb, &psn->fhand_r, &psn->fhand_r_len);

out:
       psn->lazyopen_err_r = error;
       psn->lazyopen_r = NULL;
       if (error)
               psn->stat &= ~PSN_DOLAZY_R;
       if (psn->stat & PSN_HANDLECLOSE && (psn->stat & PSN_LAZYWAIT_R) == 0)
               closehandles(pu, psn, HANDLE_READ);
moreout:
       puffs_framebuf_destroy(pb);
}

void
lazyopen_wresp(struct puffs_usermount *pu, struct puffs_framebuf *pb,
       void *arg, int error)
{
       struct psshfs_node *psn = arg;

       /* XXX: this is not enough */
       if (psn->stat & PSN_RECLAIMED) {
               error = ENOENT;
               goto moreout;
       }
       if (error)
               goto out;

       error = psbuf_expect_handle(pb, &psn->fhand_w, &psn->fhand_w_len);

out:
       psn->lazyopen_err_w = error;
       psn->lazyopen_w = NULL;
       if (error)
               psn->stat &= ~PSN_DOLAZY_W;
       if (psn->stat & PSN_HANDLECLOSE && (psn->stat & PSN_LAZYWAIT_W) == 0)
               closehandles(pu, psn, HANDLE_WRITE);
moreout:
       puffs_framebuf_destroy(pb);
}

struct readdirattr {
       struct psshfs_node *psn;
       int idx;
       char entryname[MAXPATHLEN+1];
};

int
getpathattr(struct puffs_usermount *pu, const char *path, struct vattr *vap)
{
       PSSHFSAUTOVAR(pu);

       psbuf_req_str(pb, SSH_FXP_LSTAT, reqid, path);
       GETRESPONSE(pb, pctx->sshfd);

       rv = psbuf_expect_attrs(pb, vap);

out:
       PSSHFSRETURN(rv);
}

int
getnodeattr(struct puffs_usermount *pu, struct puffs_node *pn, const char *path)
{
       struct psshfs_ctx *pctx = puffs_getspecific(pu);
       struct psshfs_node *psn = pn->pn_data;
       struct vattr va;
       int rv;

       if (!psn->attrread || REFRESHTIMEOUT(pctx, time(NULL)-psn->attrread)) {
               rv = getpathattr(pu, path ? path : PNPATH(pn), &va);
               if (rv)
                       return rv;

               setpnva(pu, pn, &va);
       }

       return 0;
}

int
sftp_readdir(struct puffs_usermount *pu, struct psshfs_ctx *pctx,
       struct puffs_node *pn)
{
       struct puffs_cc *pcc = puffs_cc_getcc(pu);
       struct psshfs_node *psn = pn->pn_data;
       struct psshfs_dir *olddir, *testd;
       struct puffs_framebuf *pb;
       uint32_t reqid = NEXTREQ(pctx);
       uint32_t count, dhandlen;
       char *dhand = NULL;
       size_t nent;
       char *longname = NULL;
       size_t idx;
       int rv;

       assert(pn->pn_va.va_type == VDIR);
       idx = 0;
       olddir = psn->dir;
       nent = psn->dentnext;

       if (psn->dir && psn->dentread
           && !REFRESHTIMEOUT(pctx, time(NULL) - psn->dentread))
               return 0;

       if (psn->dentread) {
               if ((rv = puffs_inval_namecache_dir(pu, pn)))
                       warn("readdir: dcache inval fail %p", pn);
       }

       pb = psbuf_makeout();
       psbuf_req_str(pb, SSH_FXP_OPENDIR, reqid, PNPATH(pn));
       if (puffs_framev_enqueue_cc(pcc, pctx->sshfd, pb, 0) == -1) {
               rv = errno;
               goto wayout;
       }
       rv = psbuf_expect_handle(pb, &dhand, &dhandlen);
       if (rv)
               goto wayout;

       /*
        * Well, the following is O(n^2), so feel free to improve if it
        * gets too taxing on your system.
        */

       /*
        * note: for the "getattr in batch" to work, this must be before
        * the attribute-getting.  Otherwise times for first entries in
        * large directories might expire before the directory itself and
        * result in one-by-one attribute fetching.
        */
       psn->dentread = time(NULL);

       psn->dentnext = 0;
       psn->denttot = 0;
       psn->dir = NULL;

       for (;;) {
               reqid = NEXTREQ(pctx);
               psbuf_recycleout(pb);
               psbuf_req_data(pb, SSH_FXP_READDIR, reqid, dhand, dhandlen);
               GETRESPONSE(pb, pctx->sshfd);

               /* check for EOF */
               if (psbuf_get_type(pb) == SSH_FXP_STATUS) {
                       rv = psbuf_expect_status(pb);
                       goto out;
               }
               rv = psbuf_expect_name(pb, &count);
               if (rv)
                       goto out;

               for (; count--; idx++) {
                       if (idx == psn->denttot)
                               allocdirs(psn);
                       if ((rv = psbuf_get_str(pb,
                           &psn->dir[idx].entryname, NULL)))
                               goto out;
                       if ((rv = psbuf_get_str(pb, &longname, NULL)) != 0)
                               goto out;
                       if ((rv = psbuf_get_vattr(pb, &psn->dir[idx].va)) != 0)
                               goto out;
                       if (sscanf(longname, "%*s%d",
                           &psn->dir[idx].va.va_nlink) != 1) {
                               rv = EPROTO;
                               goto out;
                       }
                       free(longname);
                       longname = NULL;

                       /*
                        * In case of DOT, copy the attributes (mostly
                        * because we want the link count for the root dir).
                        */
                       if (strcmp(psn->dir[idx].entryname, ".") == 0) {
                               setpnva(pu, pn, &psn->dir[idx].va);
                       }

                       /*
                        * Check if we already have a psshfs_dir for the
                        * name we are processing.  If so, use the old one.
                        * If not, create a new one
                        */
                       testd = lookup(olddir, nent, psn->dir[idx].entryname);
                       if (testd) {
                               psn->dir[idx].entry = testd->entry;
                               /*
                                * Has entry.  Update attributes to what
                                * we just got from the server.
                                */
                               if (testd->entry) {
                                       setpnva(pu, testd->entry,
                                           &psn->dir[idx].va);
                                       psn->dir[idx].va.va_fileid
                                           = testd->entry->pn_va.va_fileid;

                               /*
                                * No entry.  This can happen in two cases:
                                * 1) the file was created "behind our back"
                                *    on the server
                                * 2) we do two readdirs before we instantiate
                                *    the node (or run with -t 0).
                                *
                                * Cache attributes from the server in
                                * case we want to instantiate this node
                                * soon.  Also preserve the old inode number
                                * which was given when the dirent was created.
                                */
                               } else {
                                       psn->dir[idx].va.va_fileid
                                           = testd->va.va_fileid;
                                       testd->va = psn->dir[idx].va;
                               }

                       /* No previous entry?  Initialize this one. */
                       } else {
                               psn->dir[idx].entry = NULL;
                               psn->dir[idx].va.va_fileid = pctx->nextino++;
                       }
                       psn->dir[idx].attrread = psn->dentread;
                       psn->dir[idx].valid = 1;
               }
       }

out:
       /* XXX: rv */
       psn->dentnext = idx;
       freedircache(olddir, nent);

       reqid = NEXTREQ(pctx);
       psbuf_recycleout(pb);
       psbuf_req_data(pb, SSH_FXP_CLOSE, reqid, dhand, dhandlen);
       puffs_framev_enqueue_justsend(pu, pctx->sshfd, pb, 1, 0);
       free(dhand);
       free(longname);

       return rv;

wayout:
       free(dhand);
       PSSHFSRETURN(rv);
}

struct puffs_node *
makenode(struct puffs_usermount *pu, struct puffs_node *parent,
       const struct psshfs_dir *pd, const struct vattr *vap)
{
       struct psshfs_node *psn_parent = parent->pn_data;
       struct psshfs_node *psn;
       struct puffs_node *pn;

       psn = emalloc(sizeof(struct psshfs_node));
       memset(psn, 0, sizeof(struct psshfs_node));

       pn = puffs_pn_new(pu, psn);
       if (!pn) {
               free(psn);
               return NULL;
       }
       setpnva(pu, pn, &pd->va);
       setpnva(pu, pn, vap);
       psn->attrread = pd->attrread;

       psn->parent = parent;
       psn_parent->childcount++;

       TAILQ_INIT(&psn->pw);

       return pn;
}

struct puffs_node *
allocnode(struct puffs_usermount *pu, struct puffs_node *parent,
       const char *entryname, const struct vattr *vap)
{
       struct psshfs_ctx *pctx = puffs_getspecific(pu);
       struct psshfs_dir *pd;
       struct puffs_node *pn;

       pd = direnter(parent, entryname);

       pd->va.va_fileid = pctx->nextino++;
       if (vap->va_type == VDIR) {
               pd->va.va_nlink = 2;
               parent->pn_va.va_nlink++;
       } else {
               pd->va.va_nlink = 1;
       }

       pn = makenode(pu, parent, pd, vap);
       if (pn) {
               pd->va.va_fileid = pn->pn_va.va_fileid;
               pd->entry = pn;
       }

       return pn;
}

struct psshfs_dir *
direnter(struct puffs_node *parent, const char *entryname)
{
       struct psshfs_node *psn_parent = parent->pn_data;
       struct psshfs_dir *pd;
       int i;

       /* create directory entry */
       if (psn_parent->denttot == psn_parent->dentnext)
               allocdirs(psn_parent);

       i = psn_parent->dentnext;
       pd = &psn_parent->dir[i];
       pd->entryname = estrdup(entryname);
       pd->valid = 1;
       pd->attrread = 0;
       puffs_vattr_null(&pd->va);
       psn_parent->dentnext++;

       return pd;
}

void
doreclaim(struct puffs_node *pn)
{
       struct psshfs_node *psn = pn->pn_data;
       struct psshfs_node *psn_parent;
       struct psshfs_dir *dent;

       psn_parent = psn->parent->pn_data;
       psn_parent->childcount--;

       /*
        * Null out entry from directory.  Do not treat a missing entry
        * as an invariant error, since the node might be removed from
        * under us, and we might do a readdir before the reclaim resulting
        * in no directory entry in the parent directory.
        */
       dent = lookup_by_entry(psn_parent->dir, psn_parent->dentnext, pn);
       if (dent)
               dent->entry = NULL;

       if (pn->pn_va.va_type == VDIR) {
               freedircache(psn->dir, psn->dentnext);
               psn->denttot = psn->dentnext = 0;
       }
       if (psn->symlink)
               free(psn->symlink);

       puffs_pn_put(pn);
}

void
nukenode(struct puffs_node *node, const char *entryname, int reclaim)
{
       struct psshfs_node *psn, *psn_parent;
       struct psshfs_dir *pd;

       psn = node->pn_data;
       psn_parent = psn->parent->pn_data;
       pd = lookup(psn_parent->dir, psn_parent->dentnext, entryname);
       assert(pd != NULL);
       pd->valid = 0;
       free(pd->entryname);
       pd->entryname = NULL;

       if (node->pn_va.va_type == VDIR)
               psn->parent->pn_va.va_nlink--;

       if (reclaim)
               doreclaim(node);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.