Source code: com/neuron/jaffer/OS_Volume.java

   /* 
    * Copyright (c) 2003 Stewart Allen <stewart@neuron.com>. All rights reserved.
    * This program is free software. See the 'License' file for details.
    */
   
   package com.neuron.jaffer;
   
   import java.io.*;
   import java.net.*;
  import java.util.*;
  
  class OS_Volume extends AFP_Volume
  {
    private Hashtable allNodes;
    private String volName;
    private File rootDir;
    private int nextID = 32;
    private boolean readonly;
    private String passwd;
  
    OS_Volume(String vname, File droot)
    {
      this.volName = vname;
      this.rootDir = droot;
      this.allNodes = new Hashtable();
  
      OSNode root = new OSNode(0, 1, "", null);
      OSNode vol  = new OSNode(1, 2, vname, droot);
  
      root.addOffspring(vol);
      addNode(root);
    }
  
    // custom methods
    public void setReadOnly(boolean ro)
    {
      this.readonly = ro;
    }
  
    public void setPassword(String pwd)
    {
      this.passwd = pwd;
    }
  
    private synchronized int getNextID()
    {
      return nextID++;
    }
  
    private void addNode(OSNode node)
    {
      allNodes.put(new Integer(node.getNodeID()), node);
    }
  
    // abstract methods
    public String getName()
    {
      return volName;
    }
  
    public int getCreateDate()
    {
      return 0xa;
    }
  
    public int getModifiedDate()
    {
      return 0xb;
    }
  
    public int getBackupDate()
    {
      return 0x80000000;
    }
  
    public void setBackupDate(int d)
    {
    }
  
    public void setModifiedDate(int d)
    {
    }
  
    public int getAttributes()
    {
      return 
        (readonly              ? VOL_ATTR_READONLY : 0) |
        (getPassword() != null ? VOL_ATTR_PASSWORD : 0) |
        0;
    }
  
    public void setAttributes(int attr)
    {
    }
  
    public int getSignature()
    {
      return VOL_SIG_FIXED;
      //return VOL_SIG_VARIABLE;
   }
 
   public int getBlockSize()
   {
     return 0x1000;
   }
 
   public int getBytesFree()
   {
     return 0x55555555;
   }
 
   public int getBytesTotal()
   {
     return 0x66666666;
   }
 
   public long getExtBytesFree()
   {
     return 0x4545454545l;
   }
 
   public long getExtBytesTotal()
   {
     return 0x4646464646l;
   }
 
   public boolean hasUnixPrivs()
   {
     return false;
   }
 
   public String getPassword()
   {
     return passwd;
   }
 
   public AFP_CNode getCNode(int id)
   {
     return (AFP_CNode)allNodes.get(new Integer(id));
   }
 
   // utility methods
   public String flagsToString(int flags)
   {
     if (Utility.hasBits(flags, AFP_CNode.MODE_WRITE) && !readonly)
     {
       return "rw";
     }
     else
     {
       return "r";
     }
   }
 
   private boolean canOpen(File file, int flags)
   {
     boolean can = false;
     if (Utility.hasBits(flags, AFP_CNode.MODE_WRITE))
     {
       can = file.exists() ? file.canWrite() : file.getParentFile().canWrite();
     }
     else
     {
       can = file.exists() && file.canRead();
     }
     return can;
   }
 
   // -------------------------------------------------------------------------
 
   private class OSNode extends AFP_CNode
   {
     private int pid;
     private Hashtable nodes;
     private String name;
     private File file;
     private byte[] finderInfo;
     private long resourceLength;
     private volatile long modDate;
 
     OSNode(int pid, int id, String name, File file)
     {
       super(id);
       this.pid = pid;
       this.file = file;
       this.name = name;
       this.nodes = new Hashtable();
       this.resourceLength = -1;
     }
 
     // -- custom methods --
     public void setParentID(int id)
     {
       this.pid = id;
     }
 
     public synchronized void addOffspring(OSNode nn)
     {
       if (nodes == null)
       {
         nodes = new Hashtable();
       }
       nn.setParentID(getNodeID());
       nodes.put(nn.getRealName(), nn);
       addNode(nn);
     }
 
     public synchronized OSNode addOffspring(String name, File file)
     {
       if (nodes == null)
       {
         nodes = new Hashtable();
       }
       OSNode nn = new OSNode(getNodeID(), getNextID(), name, file);
       nodes.put(name, nn);
       addNode(nn);
       return nn;
     }
 
     private void saveResourceInfo()
     {
       if (finderInfo == null && resourceLength < 0)
       {
         return;
       }
       try
       {
         ResourceFork rf = getResourceFork(MODE_WRITE);
         if (rf == null)
         {
           return;
         }
         if (finderInfo != null)
         {
           rf.writeFinderInfo(finderInfo);
         }
         /*
         if (resourceLength >= 0)
         {
           rf.setLength(resourceLength);
         }
         */
         rf.close();
       }
       catch (Exception ex)
       {
         ex.printStackTrace();
       }
     }
 
     private void cacheResourceInfo()
     {
       if (finderInfo != null && resourceLength >= 0)
       {
         return;
       }
       try
       {
         ResourceFork rf = getResourceFork(MODE_READ);
         if (rf == null)
         {
           return;
         }
         if (finderInfo == null)
         {
           finderInfo = new byte[16];
         }
         rf.readFinderInfo(finderInfo);
         resourceLength = rf.getLength();
         rf.close();
       }
       catch (Exception ex)
       {
         ex.printStackTrace();
       }
     }
 
     public synchronized void scanDir()
     {
       if (file == null)
       {
         return;
       }
       long lm = file.lastModified();
       if (lm <= modDate)
       {
         return;
       }
       modDate = lm;
       String f[] = file.list();
       if (f == null || f.length == 0)
       {
         nodes.clear();
         return;
       }
       Hashtable tmp = new Hashtable(f.length*2);
       // add nodes for unknown keys
       for (int i=0; i<f.length; i++)
       {
         if (f[i].startsWith("._"))
         {
           continue;
         }
         File nn = new File(file, f[i]);
         // skip unknowns
         if (!(nn.isFile() || nn.isDirectory()))
         {
           continue;
         }
         if (nodes.get(f[i]) == null)
         {
           addOffspring(f[i], nn);
         }
         tmp.put(f[i], f[i]);
       }
       // remove stale handles
       for (Enumeration e = nodes.keys(); e.hasMoreElements(); )
       {
         Object key = e.nextElement();
         if (tmp.get(key) == null)
         {
           nodes.remove(key);
         }
       }
     }
 
     public String getRealName()
     {
       return name;
     }
 
 
     public String toString()
     {
       return "'"+name+"' {"+getNodeID()+"} "+nodes+" ";
     }
     
     private ResourceFork getResourceFork(int flags)
     {
       return (ResourceFork)openResourceFork(flags);
     }
 
     private File getResourceForkFile()
     {
       return new File(file.getParentFile(), "._"+file.getName());
     }
 
     // abstract methods
     public int getNodeType()
     {
       if (getNodeID() < 32)   { return NODE_DIRECTORY; }
       if (file == null)       { return NODE_UNKNOWN; }
       if (file.isFile())      { return NODE_FILE; }
       if (file.isDirectory()) { return NODE_DIRECTORY; }
       return NODE_UNKNOWN;
     }
 
     public boolean delete()
     {
       OSNode parent = (OSNode)getCNode(getParentNodeID());
       if (parent != null && file.delete())
       {
         getResourceForkFile().delete();
         parent.modDate = 0;
         return true;
       }
       else
       {
         return false;
       }
     }
 
     public int getParentNodeID()
     {
       return pid;
     }
 
     public int getOffspringCount()
     {
       scanDir();
       return nodes.size();
     }
 
     public int getAttributes()
     {
       return 0;
     }
 
     public void setAttributes(int attr)
     {
     }
 
     public int getOwnerID()
     {
       return 0;
     }
 
     public int getGroupID()
     {
       return 0;
     }
 
     public int getCreateDate()
     {
       return Utility.unix2afpTime(file.lastModified());
     }
 
     public void setCreateDate(int date)
     {
     }
 
     public int getModifiedDate()
     {
       return Utility.unix2afpTime(file.lastModified());
     }
 
     public void setModifiedDate(int date)
     {
       file.setLastModified(Utility.afp2unixTime(date));
     }
 
     public int getBackupDate()
     {
       return 0x80000000;
     }
 
     public void setBackupDate(int date)
     {
     }
 
     public byte[] getFinderInfo()
     {
       cacheResourceInfo();
       return finderInfo;
     }
 
     public void setFinderInfo(byte b[])
     {
       finderInfo = b;
       saveResourceInfo();
     }
 
     public String getLongName()
     {
       return name;
     }
 
     public String getShortName()
     {
       return name;
     }
 
     public String getUTF8Name()
     {
       return name;
     }
 
     public byte[] getUnixPrivs()
     {
       return null;
     }
 
     public void setUnixPrivs(byte b[])
     {
     }
 
     public int getAccessRights()
     {
       boolean read = file.canRead();
       boolean write = file.canWrite();
       //System.out.println("Access on "+file+" read="+read+" write="+write);
       return ACCESS_EVERYTHING ^ (
         (read  ? 0 : ACCESS_OWNER_READ  | ACCESS_GROUP_READ  | ACCESS_ALL_READ  | ACCESS_UA_READ ) |
         (write ? 0 : ACCESS_OWNER_WRITE | ACCESS_GROUP_WRITE | ACCESS_ALL_WRITE | ACCESS_UA_WRITE)
       );
     }
 
     public synchronized boolean moveTo(AFP_CNode dir, String name)
     {
       if (!dir.isDirectory())
       {
         return false;
       }
       File targetFile = ((OSNode)dir).file;
       File newFile = empty(name) ? targetFile : new File(targetFile, name);
       if (file.renameTo(newFile))
       {
         OSNode parent = (OSNode)getCNode(getParentNodeID());
         if (parent != null)
         {
           parent.modDate = 0;
         }
         getResourceForkFile().renameTo(new File(newFile.getParentFile(), "._"+newFile.getName()));
         file = newFile;
         return true;
       }
       else
       {
         return false;
       }
     }
 
     public AFP_CNode createDirectory(String name)
     {
       AFP_CNode ndir = getOffspringByName(name);
       if (ndir != null)
       {
         return null;
       }
       File nfdir = new File(file, name);
       if (nfdir.mkdirs())
       {
         return addOffspring(name, nfdir);
       }
       else
       {
         return null;
       }
     }
 
     public AFP_CNode createFile(String name)
     {
       AFP_CNode ndir = getOffspringByName(name);
       if (ndir != null)
       {
         return null;
       }
       File nfile = new File(file, name);
       try
       {
         if (nfile.createNewFile())
         {
           return addOffspring(name, nfile);
         }
         else
         {
           return null;
         }
       }
       catch (Exception ex)
       {
         return null;
       }
     }
 
     public AFP_CNode getOffspringByName(String name)
     {
       scanDir();
       return (AFP_CNode)nodes.get(name);
     }
 
     public Enumeration getOffspringEnumeration()
     {
       scanDir();
       return nodes.elements();
     }
 
     public int getLaunchLimit()
     {
       return 0;
     }
 
     public int getDataForkLen()
     {
       return (int)Math.min(file.length(), 0xffffffffl);
     }
 
     public int getResourceForkLen()
     {
       cacheResourceInfo();
       return (int)Math.min(resourceLength, 0xffffffffl);
     }
 
     public long getExtDataForkLen()
     {
       return file.length();
     }
 
     public long getExtResourceForkLen()
     {
       cacheResourceInfo();
       return resourceLength;
     }
 
     public AFP_Fork openFileFork(int flags)
     {
       if (!canOpen(file, flags))
       {
         return null;
       }
       try
       {
         return new DataFork(file, flags);
       }
       catch (Exception ex)
       {
         ex.printStackTrace();
         return null;
       }
     }
 
     public AFP_Fork openResourceFork(int flags)
     {
       // you can't create a resource fork if you don't have
       // the same priviledges on the data fork
       if (getNodeID() < 32 || !canOpen(getResourceForkFile(), flags) || !canOpen(file, flags))
       {
         return null;
       }
       try
       {
         return new ResourceFork(getResourceForkFile(), flags);
       }
       catch (Exception ex)
       {
         ex.printStackTrace();
         return null;
       }
     }
   }
 
   // -------------------------------------------------------------------------
 
   private class ResourceFork extends DataFork
   {
     private File file;
 
     ResourceFork(File file, int flags)
       throws IOException
     {
       super(new AppleDouble(file, flagsToString(flags)));
       this.file = file;
     }
 
     public File file()
     {
       return file;
     }
 
     public void renameTo(File dst)
     {
       if (file.renameTo(dst))
       {
         file = dst;
       }
     }
 
     public int getForkType()
     {
       return FORK_RESOURCE;
     }
 
     public void readFinderInfo(byte b[])
       throws IOException
     {
       ((AppleDouble)nativeFile()).readFinderInfo(b);
     }
 
     public void writeFinderInfo(byte b[])
       throws IOException
     {
       ((AppleDouble)nativeFile()).writeFinderInfo(b);
     }
   }
 
   // -------------------------------------------------------------------------
 
   private class DataFork extends AFP_Fork
   {
     private RandomAccessFile file;
 
     DataFork(File file, int flags)
       throws IOException
     {
       this(new RandomAccessFile(file, flagsToString(flags)));
     }
 
     DataFork(RandomAccessFile file)
       throws IOException
     {
       this.file = file;
     }
 
     public RandomAccessFile nativeFile()
     {
       return file;
     }
 
     public int getForkType()
     {
       return FORK_DATA;
     }
 
     public void readRange(long offset, long length, ByteWriter ww)
       throws IOException
     {
       length = Math.min(getLength() - offset, length);
       if (length < 0 || offset < 0)
       {
         throw new EOFException();
       }
       file.seek(offset);
       ww.readFromFile(file, length);
     }
 
     public long writeRange(long offset, long length, ByteReader rr)
       throws IOException
     {
       file.seek(offset);
       return rr.writeToFile(file, length);
     }
 
     public long getLength()
       throws IOException
     {
       return file.length();
     }
 
     public void setLength(long len)
       throws IOException
     {
       file.setLength(len);
     }
 
     public void flush()
       throws IOException
     {
       file.getFD().sync();
     }
 
     public void close()
     {
       try
       {
         file.close();
       }
       catch (Exception ex)
       {
         ex.printStackTrace();
       }
     }
   }
 }