开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
mod_tar.c
资源名称：proftpd-1.2.0pre8.tar.gz　[点击查看]
上传用户：pycemail
上传日期：2007-01-04
资源大小：329k
文件大小：18k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

mod_tar.c：源码内容
  1. #include "conf.h"
  3. #include <tar.h>
  5. typedef struct tar_dir {
  6.   struct tar_dir *next;
  8.   char *t_path;
  9.   char *t_dir;
  10.   umode_t t_mode;
  11.   int t_islink;
  12.   uid_t t_uid;
  13.   gid_t t_gid;
  14.   size_t t_size;
  15.   time_t t_mtime;
  16.   char *t_uname;
  17.   char *t_gname;
  18.   union {
  19.     char *linkname;
  20.     struct {
  21.       unsigned int devmajor;
  22.       unsigned int devminor;
  23.     } device;
  24.     unsigned long offset;
  25.     struct tar_dir *directory;
  26.   } i;
  27. } tardir_t;
  29. typedef struct tar_file {
  30.   pool *p;
  32.   char *path;
  33.   int fd,fd_open;
  34.   fsdir_t *f;
  35.   tardir_t *dir,*tf_cwd;
  37.   unsigned long pos;
  39.   time_t tf_mtime;
  40.   uid_t tf_uid;
  41.   gid_t tf_gid;
  42.   char *tf_uname;
  43.   char *tf_gname;
  44.   struct stat tf_stat;
  45. } tarfile_t;
  47. typedef struct tar_internal {
  48.   unsigned long offset,pos,size;
  49. } tarinternal_t;
  51. #define MAX_OPEN_INTERNAL_FILES  32
  53. static int of_marker = 0;
  54. static tarinternal_t *open_files[MAX_OPEN_INTERNAL_FILES];
  56. static tardir_t *create_tar_dirlink(tarfile_t *tf, tardir_t *t, const char *name)
  57. {
  58.   tardir_t *newt;
  60.   newt = (tardir_t*)pcalloc(tf->p,sizeof(tardir_t));
  61.   newt->t_path = newt->t_dir = pstrdup(tf->p,name);
  62.   if(!t) {
  63.     newt->t_mode = 0755 | S_IFDIR;
  64.     newt->t_mtime = tf->tf_mtime;
  65.     newt->t_uid = tf->tf_uid;
  66.     newt->t_gid = tf->tf_gid;
  67.     newt->t_uname = tf->tf_uname;
  68.     newt->t_gname = tf->tf_gname;
  69.   } else {
  70.     newt->t_mode = t->t_mode;
  71.     newt->t_mtime = t->t_mtime;
  72.     newt->t_uid = t->t_uid;
  73.     newt->t_gid = t->t_gid;
  74.     newt->t_uname = t->t_uname;
  75.     newt->t_gname = t->t_gname;
  76.   }
  78.   newt->i.directory = t;
  80.   return newt;
  81. }
  83. static tardir_t *create_tar_directory(tarfile_t *tf, tardir_t *parent, const char *path)
  84. {
  85.   tardir_t *t,*dott,*dotdott;
  87.   t = (tardir_t*)pcalloc(tf->p,sizeof(tardir_t));
  88.   t->t_path = t->t_dir = pstrdup(tf->p,path);
  89.   t->t_mode = 0755 | S_IFDIR;
  91.   t->t_mtime = tf->tf_mtime;
  92.   t->t_uid = tf->tf_uid;
  93.   t->t_gid = tf->tf_gid;
  94.   t->t_uname = tf->tf_uname;
  95.   t->t_gname = tf->tf_gname;
  97.   dott = create_tar_dirlink(tf,t,".");
  98.   t->i.directory = dott;
  99.   dotdott = create_tar_dirlink(tf,parent,"..");
  100.   dott->next = dotdott;
  102.   return t;
  103. }
  105. static unsigned long _cvt_octal(char *buf, int size)
  106. {
  107.   unsigned long l;
  108.   char tmp[33];
  109.   char *endp;
  111.   sstrncpy(tmp, buf, size);
  112.   
  113.   l = strtol(tmp,&endp,8);
  114.   return l;  
  115. }
  117. static tardir_t *readtarfile_ent(tarfile_t *tf)
  118. {
  119.   pool *p;
  120.   tardir_t *t;
  121.   unsigned char buf[512],tmpbuf[256],*cp;
  122.   unsigned long chksum,blocks;
  123.   unsigned char filetype;
  124.   uid_t uid;
  125.   gid_t gid;
  126.   unsigned int tmode;
  127.   int len,i;
  129.   p = tf->p;
  131.   /* read the header */
  132.   len = tf->f->read(tf->f,tf->fd,buf,sizeof(buf));
  133.   if(len < 512)
  134.     return NULL;
  136.   tf->pos += 512;
  138.   chksum = _cvt_octal(&buf[148],8);
  139.   memcpy(&buf[148],"        ",8);
  140.   for(i = 0; i < 512; i++)
  141.     chksum -= buf[i];
  143.   if(chksum)
  144.     return NULL;
  146.   t = (tardir_t*)pcalloc(p,sizeof(tardir_t));
  147.   sstrncpy(tmpbuf, &buf[345], 155);
  148.   t->t_path = pstrdup(p, tmpbuf);
  149.   sstrncpy(tmpbuf, &buf[0], 100);
  150.   t->t_path = pdircat(p,t->t_path,tmpbuf,NULL);
  151.   if(!strncmp(t->t_path,"./",2))
  152.     t->t_path += 2;
  153.   if(!strncmp(t->t_path,"../",3))
  154.     t->t_path += 3;
  155.   if(*t->t_path == '/')
  156.     t->t_path++;
  158.   if(*(t->t_path + strlen(t->t_path) - 1) == '/') {
  159.     *(t->t_path + strlen(t->t_path) - 1) = '';
  160.   }
  162.   sstrncpy(tmpbuf,t->t_path,sizeof(tmpbuf));
  163.   if((cp = rindex(tmpbuf,'/')) != NULL) {
  164.     *cp = '';
  165.     t->t_dir = pstrdup(p,tmpbuf);
  166.   } else
  167.     t->t_dir = "";
  169.   t->t_uid = _cvt_octal(&buf[108],8);
  170.   t->t_gid = _cvt_octal(&buf[116],8);
  171.   t->t_size = _cvt_octal(&buf[124],12);
  172.   t->t_mtime = _cvt_octal(&buf[136],12);
  173.   sstrncpy(tmpbuf,&buf[265],32);
  174.   t->t_uname = pstrdup(p,tmpbuf);
  175.   sstrncpy(tmpbuf,&buf[297],32);
  176.   t->t_gname = pstrdup(p,tmpbuf);
  177.   tmode = _cvt_octal(&buf[100],8);
  179.   if(tmode & TSUID)
  180.     t->t_mode |= S_ISUID;
  181.   if(tmode & TSGID)
  182.     t->t_mode |= S_ISGID;
  183.   if(tmode & TSVTX)
  184.     t->t_mode |= S_ISVTX;
  185.   if(tmode & TUREAD)
  186.     t->t_mode |= S_IRUSR;
  187.   if(tmode & TUWRITE)
  188.     t->t_mode |= S_IWUSR;
  189.   if(tmode & TUEXEC)
  190.     t->t_mode |= S_IXUSR;
  191.   if(tmode & TGREAD)
  192.     t->t_mode |= S_IRGRP;
  193.   if(tmode & TGWRITE)
  194.     t->t_mode |= S_IWGRP;
  195.   if(tmode & TGEXEC)
  196.     t->t_mode |= S_IXGRP;
  197.   if(tmode & TOREAD)
  198.     t->t_mode |= S_IROTH;
  199.   if(tmode & TOWRITE)
  200.     t->t_mode |= S_IWOTH;
  201.   if(tmode & TOEXEC)
  202.     t->t_mode |= S_IXOTH;
  204.   filetype = buf[156];
  206.   switch(filetype) {
  207.   case LNKTYPE:
  208.     t->t_islink = 1;
  209.     break;
  210.   case SYMTYPE:
  211.     t->t_mode |= S_IFLNK;
  212.     sstrncpy(tmpbuf,&buf[157],100);
  213.     t->i.linkname = pstrdup(p,tmpbuf);
  214.     break;
  215.   case CHRTYPE:
  216.     t->t_mode |= S_IFCHR;
  217.     t->i.device.devmajor = _cvt_octal(&buf[329],8);
  218.     t->i.device.devminor = _cvt_octal(&buf[337],8);
  219.     break;
  220.   case BLKTYPE:
  221.     t->t_mode |= S_IFBLK;
  222.     t->i.device.devmajor = _cvt_octal(&buf[329],8);
  223.     t->i.device.devminor = _cvt_octal(&buf[337],8);
  224.     break;
  225.   case DIRTYPE:
  226.     t->t_mode |= S_IFDIR;
  227.     t->t_dir = t->t_path;
  228.     break;
  229.   case FIFOTYPE:
  230.     t->t_mode |= S_IFIFO;
  231.     break;
  232.   default:
  233.     t->t_mode |= S_IFREG;
  234.     t->i.offset = tf->pos;
  235.     break;
  236.   }
  238.   blocks = t->t_size / 512;
  239.   if(t->t_size % 512)
  240.     blocks++;
  242.   if(blocks) {
  243.     tf->f->lseek(tf->f,tf->fd,blocks*512,SEEK_CUR);
  244.     tf->pos += (blocks * 512);
  245.   }
  246.   /* fixup uid and gid if possible */
  247.   uid = auth_name_uid(p,t->t_uname);
  248.   gid = auth_name_gid(p,t->t_gname);
  250.   if(uid != -1)
  251.     t->t_uname = pstrdup(p,auth_uid_name(p,uid));
  252.   if(gid != -1)
  253.     t->t_gname = pstrdup(p,auth_gid_name(p,gid));
  255.   return t;
  256. }
  258. static void _dump(tardir_t *t, int tab)
  259. {
  260.   int i;
  261.   for(; t; t=t->next) {
  262.     for(i = 0; i < tab; i++)
  263.       printf("  ");
  264.     printf("%s",t->t_path);
  265.     if(S_ISDIR(t->t_mode)) {
  266.       if(!strcmp(t->t_path,"..") || !strcmp(t->t_path,".")) {
  267.         printf(" -> ");
  268.         printf("%sn",(t->i.directory ? t->i.directory->t_path : "ROOT"));
  269.       } else if(t->i.directory) {
  270.         printf("n");
  271.         _dump(t->i.directory,tab+1);
  272.       } else
  273.         printf("n");
  274.     } else
  275.       printf("n");
  276.   }
  277. }
  279. static int readtarfile_directory(tarfile_t *tf)
  280. {
  281.   int ret = -1,found;
  282.   tardir_t *t,*newdir,**head,*parent;
  283.   char path[MAXPATHLEN],*ptr,*dir;
  285.   tf->pos = 0;
  286.   tf->dir = create_tar_dirlink(tf,NULL,".");
  287.   tf->dir->i.directory = tf->dir;
  289.   while((t = readtarfile_ent(tf)) != NULL) {
  290.     sstrncpy(path,t->t_dir,sizeof(path));
  291.     ptr = dir = path;
  292.     if(*ptr && *ptr == '/') {
  293.       ptr++; dir++;
  294.     }
  296.     head = &tf->dir->i.directory; parent = tf->dir;
  298.     while(ptr) {
  299.       ptr = index(ptr,'/');
  300.       if(ptr)
  301.         *ptr = '';
  303.       found = 0;
  304.       /* insert into the directory list */
  305.       while(*head) {
  306.         if(S_ISDIR((*head)->t_mode) && !strcmp((*head)->t_dir,dir)) {
  307.           found++;
  308.           break;
  309.         } else
  310.           head = &(*head)->next;
  311.       }
  313.       if(S_ISDIR(t->t_mode)) {
  314.         if(*head) {
  315.           if(S_ISDIR((*head)->t_mode) && !strcmp((*head)->t_path,t->t_path)) {
  316.             ptr = NULL;
  317.             ret = 0;
  318.           } else {
  319.             parent = *head;
  320.             head = &(*head)->i.directory;
  321.           }
  322.         } else {
  323.           if(ptr) {
  324.             newdir = create_tar_directory(tf,parent,dir);
  325.             *head = parent = newdir;
  326.             head = &newdir->i.directory;
  327.           } else {
  328.             tardir_t *dott,*dotdott;
  330.             dott = create_tar_dirlink(tf,t,".");
  331.             dotdott = create_tar_dirlink(tf,parent,"..");
  332.  
  333.             dott->next = dotdott;
  334.             t->i.directory = dott;
  335.             t->next = *head;
  336.             *head = parent = t;
  337.             ret = 0;
  338.           }
  339.         }
  340.       } else {
  341.         if(!ptr) {
  342.           /* insert here */
  343.           if(*head && S_ISDIR((*head)->t_mode)) {
  344.             parent = *head;
  345.             head = &(*head)->i.directory;
  346.           } t->next = *head;
  347.           *head = t;
  348.           ret = 0;
  349.         } else if(!*head) {
  350.           /* need to add this directory */
  351.           newdir = create_tar_directory(tf,parent,dir);
  352.           *head = parent = newdir;
  353.           head = &newdir->i.directory;
  354.         } else {
  355.           parent = *head;
  356.           head = &(*head)->i.directory;
  357.         }
  358.       }
  360.       if(ptr)
  361.         *ptr++ = '/';
  362.     }
  364.     if(ret == -1)
  365.       break;
  366.   }
  368. #if 1
  369.   _dump(tf->dir,0);
  370. #endif
  371.   return ret;
  372. }
  374. static tarfile_t *opentarfile(fsdir_t *f, const char *name)
  375. {
  376.   int fd;
  377.   tarfile_t *tf;
  378.   struct stat sbuf;
  379.   pool *p;
  381.   if(f->stat(f,name,&sbuf) == -1)
  382.     return NULL;
  384.   fd = f->open(f,name,O_RDONLY);
  385.   if(fd == -1)
  386.     return NULL;
  388.   p = make_sub_pool(permanent_pool);
  389.   tf = (tarfile_t*)pcalloc(p,sizeof(tarfile_t));
  390.   tf->p = p;
  391.   tf->fd = fd;
  392.   tf->fd_open = -1;
  393.   tf->f = f;
  394.   tf->path = pstrdup(p,name);
  396.   tf->tf_mtime = sbuf.st_mtime;
  397.   tf->tf_uid = sbuf.st_uid;
  398.   tf->tf_gid = sbuf.st_gid;
  399.   tf->tf_uname = pstrdup(tf->p,auth_uid_name(tf->p,sbuf.st_uid));
  400.   tf->tf_gname = pstrdup(tf->p,auth_gid_name(tf->p,sbuf.st_gid));
  402.   memcpy(&tf->tf_stat,&sbuf,sizeof(sbuf));
  404.   readtarfile_directory(tf);
  405.   f->close(f,fd);
  406.   tf->fd = -1;
  407.   return tf;
  408. }
  410. static void closetarfile(fsdir_t *f)
  411. {
  412.   tarfile_t *tf;
  414.   tf = (tarfile_t*)f->private;
  415.   if(tf && tf->fd != -1 && tf->fd_open == -1) {
  416.     f->parent->close(f->parent,tf->fd);
  417.     tf->fd = -1;
  418.   }
  419. }
  421. static tarfile_t *checktarfile(fsdir_t *f)
  422. {
  423.   tarfile_t *tf;
  424.  
  425.   tf = (tarfile_t*)f->private;
  426.   if(!tf) {
  427.     f->private = tf = opentarfile(f->parent,f->name);
  428.     if(tf) {
  429.       f->parent->lseek(f->parent,tf->fd,0,SEEK_SET);
  430.       tf->pos = 0;
  431.     }
  432.   } else {
  433.     if(tf->fd == -1) {
  434.       tf->fd = f->parent->open(f->parent,f->name,O_RDONLY);
  435.       tf->pos = 0;
  436.       if(tf->fd == -1)
  437.         return NULL;
  438.     }
  439.   }
  441.   return tf;
  442. }
  444. static tardir_t *tarfile_gettardir(tarfile_t *tf, tardir_t *t, const char *path)
  445. {
  446.   if(*path == '/')
  447.     path++;
  449.   if(!*path)
  450.     return tarfile_gettardir(tf,tf->dir,".");
  452.   if(!t)
  453.     t = tf->dir->i.directory;
  455.   while(t) {
  456.     if(!strcmp(t->t_path,path))
  457.       break;
  458.     if(S_ISDIR(t->t_mode) && !strncmp(t->t_path,path,strlen(t->t_path)) &&
  459.        strcmp(t->t_path,"."))
  460.       t = t->i.directory;
  461.     else
  462.       t = t->next;
  463.   }
  465.   return t;
  466. }
  468. static char local[MAXPATHLEN];
  469. static char local_cwd[MAXPATHLEN] = "/";
  471. static int get_local(fsdir_t *f, const char *path, char *buf, int maxlen)
  472. {
  473.   char tmp[MAXPATHLEN];
  474.   register int l = strlen(f->name);
  476.   if(*path == '/' && !strncmp(f->name,path,l))
  477.     sstrncpy(tmp,path+l,maxlen - l);
  478.   else {
  479.     *tmp = '';
  480.     fs_dircat(tmp,sizeof(tmp),local_cwd,path);
  481.   }
  483.   fs_clean_path(tmp,buf,maxlen);
  484.   return 0;
  485. }
  487. static int tar_chdir(fsdir_t *f, const char *path)
  488. {
  489.   tarfile_t *tf;
  490.   tardir_t *t;
  492.   tf = checktarfile(f);
  493.   if(!tf)
  494.     return -1;
  496.   get_local(f,path,local,sizeof(local));
  498.   t = tarfile_gettardir(tf,NULL,local);
  499.   if(!t) {
  500.     errno = ENOENT;
  501.     return -1;
  502.   }
  504.   if(!S_ISDIR(t->t_mode)) {
  505.     errno = ENOTDIR;
  506.     return -1;
  507.   }
  509.   tf->tf_cwd = t->i.directory;
  510.   sstrncpy(local_cwd,local,sizeof(local));
  512.   closetarfile(f);
  513.   return 0;
  514. }
  516. static int tar_readlink(fsdir_t *f, const char *path, char *buf, size_t bufsiz)
  517. {
  518.   tarfile_t *tf;
  519.   tardir_t *t;
  521.   tf = checktarfile(f);
  522.   if(!tf)
  523.     return -1;
  525.   get_local(f,path,local,sizeof(local));
  526.   t = tarfile_gettardir(tf,NULL,local);
  527.   if(!t) {
  528.     errno = ENOENT;
  529.     return -1;
  530.   }
  532.   if(!S_ISLNK(t->t_mode)) {
  533.     errno = EINVAL;
  534.     return -1;
  535.   }
  537.   sstrncpy(buf,t->i.linkname,bufsiz);
  538.   closetarfile(f);
  539.   return strlen(buf);
  540. }
  542. static int tar_lstat(fsdir_t *f, const char *path, struct stat *sbuf)
  543. {
  544.   tarfile_t *tf;
  545.   tardir_t *t;
  547.   tf = checktarfile(f);
  548.   if(!tf)
  549.     return -1;
  551.   get_local(f,path,local,sizeof(local));
  552.   t = tarfile_gettardir(tf,NULL,local);
  553.   if(!t) {
  554.     closetarfile(f);
  555.     errno = ENOENT;
  556.     return -1;
  557.   }
  559.   if(!strcmp(local,"/")) {
  560.     memcpy(sbuf,&tf->tf_stat,sizeof(struct stat));
  561.     sbuf->st_mode = t->t_mode;
  562.   } else {
  563.     bzero(sbuf,sizeof(struct stat));
  564.     sbuf->st_ino = (ino_t)t;
  565.     sbuf->st_mode = t->t_mode;
  566.     sbuf->st_nlink = 1;
  567.     sbuf->st_uid = t->t_uid;
  568.     sbuf->st_gid = t->t_gid;
  569.     sbuf->st_size = t->t_size;
  570.     sbuf->st_atime = sbuf->st_mtime = sbuf->st_ctime = t->t_mtime;
  571.     if(S_ISREG(t->t_mode)) {
  572.       sbuf->st_blksize = 512;
  573.       sbuf->st_blocks = t->t_size / 512;
  574.       if(t->t_size % 512)
  575.         sbuf->st_blocks++;
  576.     }
  577.   }
  579.   closetarfile(f);
  580.   return 0;
  581. }
  583. static int tar_stat(fsdir_t *f, const char *path, struct stat *sbuf)
  584. {
  585.   if(tar_lstat(f,path,sbuf) == -1)
  586.     return -1;
  588.   if(S_ISLNK(sbuf->st_mode)) {
  589.     char linkbuf[MAXPATHLEN];
  591.     if(tar_readlink(f,path,linkbuf,sizeof(linkbuf)) == -1)
  592.       return -1;
  594.     return fs_stat(linkbuf,sbuf);
  595.   }
  597.   return 0;
  598. }
  600. static int tar_close(fsdir_t *f, int fd)
  601. {
  602.   tarfile_t *tf;
  604.   tf = checktarfile(f);
  605.   if(!tf)
  606.     return -1;
  608.   if(!open_files[fd]) {
  609.     errno = EBADF;
  610.     return -1;
  611.   }
  613.   free(open_files[fd]);
  614.   open_files[fd] = NULL;
  615.   while(of_marker && !open_files[of_marker])
  616.     of_marker--;
  618.   if(!of_marker) {
  619.     tf->fd_open = -1;
  620.     closetarfile(f);
  621.   }
  623.   return 0;
  624. }
  626. static int tar_open(fsdir_t *f, const char *path, int access)
  627. {
  628.   tarinternal_t *ti;
  629.   tarfile_t *tf;
  630.   tardir_t *t;
  632.   tf = checktarfile(f);
  633.   if(!tf)
  634.     return -1;
  636.   get_local(f,path,local,sizeof(local));
  637.   t = tarfile_gettardir(tf,NULL,local);
  638.   if(!t) {
  639.     closetarfile(f);
  640.     errno = ENOENT;
  641.     return -1;
  642.   }
  644.   if(!S_ISREG(t->t_mode)) {
  645.     closetarfile(f);
  646.     errno = EACCES;
  647.     return -1;
  648.   }
  649.   if(session.uid == t->t_uid) {
  650.     if((t->t_mode & S_IRUSR) == 0) {
  651.       closetarfile(f);
  652.       errno = EACCES;
  653.       return -1;
  654.     }
  655.   } else if(session.gid == t->t_gid) {
  656.     if((t->t_mode & S_IRGRP) == 0) {
  657.       closetarfile(f);
  658.       errno = EACCES;
  659.       return -1;
  660.     }
  661.   } else {
  662.     if((t->t_mode & S_IROTH) == 0) {
  663.       closetarfile(f);
  664.       errno = EACCES;
  665.       return -1;
  666.     }
  667.   }
  668.   
  669.   if(of_marker == MAX_OPEN_INTERNAL_FILES) {
  670.     closetarfile(f);
  671.     errno = ENFILE;
  672.     return -1;
  673.   }
  675.   ti = open_files[of_marker++] = malloc(sizeof(tarinternal_t));
  676.   if(!ti) {
  677.     closetarfile(f);
  678.     errno = ENOMEM;
  679.     return -1;
  680.   }
  682.   ti->pos = ti->offset = t->i.offset;
  683.   ti->size = t->t_size;
  685.   if(f->parent->lseek(f->parent,tf->fd,ti->pos,SEEK_SET) == -1) {
  686.     int hold_errno = errno;
  687.     closetarfile(f);
  688.     return -1;
  689.   }
  691.   tf->fd_open = tf->fd;
  692.   return of_marker-1;
  693. }
  695. static int tar_write(fsdir_t *f, int fd, const char *buf, size_t size)
  696. {
  697.   errno = EACCES;
  698.   return -1;
  699. }
  700.   
  701. static int tar_read(fsdir_t *f, int fd, char *buf, size_t size)
  702. {
  703.   tarinternal_t *ti;
  704.   tarfile_t *tf;
  705.   int bread;
  707.   tf = checktarfile(f);
  708.   if(!tf)
  709.     return -1;
  711.   if(fd < 0 || fd >= MAX_OPEN_INTERNAL_FILES || (ti = open_files[fd]) == NULL) {
  712.     closetarfile(f);
  713.     errno = EBADF;
  714.     return -1;
  715.   }
  716.   
  717.   if(ti->pos >= (ti->offset + ti->size))
  718.     return 0;
  720.   if((ti->pos - ti->offset) + size >= ti->size)
  721.     size = ti->size - (ti->pos - ti->offset);
  723.   if(tf->pos != ti->pos) {
  724.     if(f->parent->lseek(f->parent,tf->fd,ti->pos,SEEK_SET) == -1)
  725.       return -1;
  726.     tf->pos = ti->pos;
  727.   }
  728.   
  729.   bread = f->parent->read(f->parent,tf->fd,buf,size);
  730.   if(bread <= 0)
  731.     return bread;
  733.   tf->pos += bread;
  734.   ti->pos += bread;
  735.   return bread;
  736. }
  738. static off_t tar_lseek(fsdir_t *f, int fd, off_t offset, int whence)
  739. {
  740.   tarinternal_t *ti;
  741.   tarfile_t *tf;
  743.   tf = checktarfile(f);
  744.   if(!tf)
  745.     return -1;
  747.   if(fd < 0 || fd >= MAX_OPEN_INTERNAL_FILES || (ti = open_files[fd]) == NULL) {
  748.     closetarfile(f);
  749.     errno = EBADF;
  750.     return -1;
  751.   }
  753.   switch(whence) {
  754.   case SEEK_CUR:
  755.     offset += (ti->pos - ti->offset);
  756.     break;
  757.   case SEEK_END:
  758.     offset += ti->size;
  759.     break;
  760.   }
  762.   if(offset < 0)
  763.     offset = 0;
  764.   if(offset > ti->size)
  765.     offset = ti->size;
  767.   ti->pos = ti->offset + offset;
  768.   return offset;
  769. }
  771. static void *tar_opendir(fsdir_t *f, const char *path)
  772. {
  773.   tarfile_t *tf;
  774.   tardir_t *t,**cursor;
  776.   tf = checktarfile(f);
  777.   if(!tf)
  778.     return NULL;
  780.   get_local(f,path,local,sizeof(local));
  781.   t = tarfile_gettardir(tf,NULL,local);
  782.   if(!t) {
  783.     closetarfile(f);
  784.     errno = ENOENT;
  785.     return NULL;
  786.   }
  788.   if(!S_ISDIR(t->t_mode)) {
  789.     closetarfile(f);
  790.     errno = ENOTDIR;
  791.     return NULL;
  792.   }
  794.   cursor = malloc(sizeof(tardir_t*));
  795.   *cursor = t->i.directory;
  796.   return cursor;
  797. }
  798.  
  799. static struct dirent *tar_readdir(fsdir_t *f, void *_dir)
  800. {
  801.   tardir_t *t,**cursor = (tardir_t**)_dir;
  802.   char tmpbuf[MAXPATHLEN],*cp;
  803.   static struct dirent dir;
  805.   if(!cursor || !*cursor)
  806.     return NULL;
  808.   t = *cursor;
  809.   dir.d_ino = (long)t;
  810.   dir.d_off = 0;
  811.   dir.d_reclen = sizeof(struct dirent);
  812.   dir.d_type = 0;
  813.   
  814.   sstrncpy(tmpbuf,t->t_path,sizeof(tmpbuf));
  815.   if((cp = rindex(tmpbuf,'/')) != NULL)
  816.     *cp++ = '';
  817.   else
  818.     cp = tmpbuf;
  820.   sstrncpy(dir.d_name,cp,NAME_MAX);
  822.   *cursor = t->next;
  823.   return &dir;
  824. }  
  826. static int tar_closedir(fsdir_t *f, void *_dir)
  827. {
  828.   tardir_t **cursor = (tardir_t**)_dir;
  830.   if(cursor)
  831.     free(cursor);
  833.   closetarfile(f);
  834.   return 0;
  835. }
  836.   
  837. static int tar_hit(fsdir_t *f, const char *path, int op)
  838. {
  839.   fsdir_t *newfs;
  840.   struct stat sbuf;
  841.   char buf[MAXPATHLEN];
  843. #if 0
  844.   if(op == FSOP_OPEN) {
  845. #endif
  846.     if(f->stat(f,path,&sbuf) == -1)
  847.       return -1;
  849.     if(!S_ISREG(sbuf.st_mode))
  850.       return 0;
  852.     fs_resolve_path(path,buf,sizeof(buf),0);
  854.     newfs = fs_register(buf);
  855.     newfs->chdir = &tar_chdir;
  856.     newfs->lstat = &tar_lstat;
  857.     newfs->stat = &tar_stat;
  858.     newfs->readlink = &tar_readlink;
  859.     newfs->open = &tar_open;
  860.     newfs->close = &tar_close;
  861.     newfs->read = &tar_read;
  862.     newfs->write = &tar_write;
  863.     newfs->lseek = &tar_lseek;
  864.     newfs->opendir = &tar_opendir;
  865.     newfs->readdir = &tar_readdir;
  866.     newfs->closedir = &tar_closedir;
  867. #if 0
  868.     newfs->open = &html_open;
  869.     newfs->close = &html_close;
  870.     newfs->read = &html_read;
  871.     newfs->write = &html_write;
  872. #endif
  873.     return 1;
  874. #if 0
  875.   }
  876. #endif
  878.   return 0;
  879. }
  881. static int tar_init()
  882. {
  883.   fsmatch_t *fm;
  885.   bzero(open_files,sizeof(open_files));
  886.   fm = fs_register_match("*.tar",0xffffffff);
  887.   fm->dir_hit = fm->file_hit = tar_hit;
  889.   return 0;
  890. }
  892. module tar_module = {
  893.   NULL,NULL,
  894.   0x20,
  895.   "tar",
  896.   NULL,
  897.   NULL,
  898.   NULL,
  899.   tar_init,NULL
  900. };