diff options
Diffstat (limited to 'tdeioslave/iso/kiso.cpp')
| -rw-r--r-- | tdeioslave/iso/kiso.cpp | 460 |
1 files changed, 460 insertions, 0 deletions
diff --git a/tdeioslave/iso/kiso.cpp b/tdeioslave/iso/kiso.cpp new file mode 100644 index 000000000..7556a3350 --- /dev/null +++ b/tdeioslave/iso/kiso.cpp @@ -0,0 +1,460 @@ +/*************************************************************************** + kiso.cpp + ------------------- + begin : Oct 25 2002 + copyright : (C) 2002 by Szombathelyi Gy�gy + email : gyurco@users.sourceforge.net + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + + /* This file is heavily based on ktar.cpp from tdelibs (c) David Faure */ + +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <unistd.h> +#include <grp.h> +#include <pwd.h> +#include <assert.h> +#include <sys/types.h> +#include <sys/stat.h> + +#include <tqcstring.h> +#include <tqdir.h> +#include <tqfile.h> +#include <kdebug.h> +#include <kurl.h> +#include <kmimetype.h> +#include <tdeconfig.h> +#include <kfilterdev.h> +#include <kfilterbase.h> + +#include "kiso.h" +#include "libisofs/isofs.h" +#include "qfilehack.h" + + +#ifdef __linux__ +#undef __STRICT_ANSI__ +#include <linux/cdrom.h> +#define __STRICT_ANSI__ +#include <sys/ioctl.h> +#include <fcntl.h> +#endif + +//////////////////////////////////////////////////////////////////////// +/////////////////////////// KIso /////////////////////////////////// +//////////////////////////////////////////////////////////////////////// + +/** + * puts the track layout of the device 'fname' into 'tracks' + * tracks structure: start sector, track number, ... + * tracks should be 100*2 entry long (this is the maximum in the CD-ROM standard) + * currently it's linux only, porters are welcome + */ +static int getTracks(const char *fname,int *tracks) { + int ret=0; + memset(tracks,0,200*sizeof(int)); + +#ifdef __linux__ + int fd,i; + struct cdrom_tochdr tochead; + struct cdrom_tocentry tocentry; + + kdDebug() << "getTracks open:" << fname << endl; + fd=open(fname, O_RDONLY | O_NONBLOCK); + if (fd > 0) { + if (ioctl(fd,CDROMREADTOCHDR,&tochead)!=-1) { + kdDebug() << "getTracks first track:" << tochead.cdth_trk0 + << " last track " << tochead.cdth_trk1 << endl; + for (i=tochead.cdth_trk0;i<=tochead.cdth_trk1;i++) { + if (ret>99) break; + memset(&tocentry,0,sizeof(struct cdrom_tocentry)); + tocentry.cdte_track=i; + tocentry.cdte_format=CDROM_LBA; + if (ioctl(fd,CDROMREADTOCENTRY,&tocentry)<0) break; + kdDebug() << "getTracks got track " << i << " starting at: " << + tocentry.cdte_addr.lba << endl; + if ((tocentry.cdte_ctrl & 0x4) == 0x4) { + tracks[ret<<1]=tocentry.cdte_addr.lba; + tracks[(ret<<1)+1]=i; + ret++; + } + } + } + close(fd); + } + +#endif + + return ret; +} + +class KIso::KIsoPrivate +{ +public: + KIsoPrivate() {} + TQStringList dirList; +}; + +KIso::KIso( const TQString& filename, const TQString & _mimetype ) + : KArchive( 0L ) +{ + m_startsec = -1; + m_filename = filename; + d = new KIsoPrivate; + TQString mimetype( _mimetype ); + bool forced = true; + if ( mimetype.isEmpty() ) + { + mimetype = KMimeType::findByFileContent( filename )->name(); + kdDebug() << "KIso::KIso mimetype=" << mimetype << endl; + + // Don't move to prepareDevice - the other constructor theoretically allows ANY filter + if ( mimetype == "application/x-tgz" || mimetype == "application/x-targz" || // the latter is deprecated but might still be around + mimetype == "application/x-webarchive" ) + // that's a gzipped tar file, so ask for gzip filter + mimetype = "application/x-gzip"; + else if ( mimetype == "application/x-tbz" ) // that's a bzipped2 tar file, so ask for bz2 filter + mimetype = "application/x-bzip2"; + else + { + // Something else. Check if it's not really gzip though (e.g. for KOffice docs) + TQFile file( filename ); + if ( file.open( IO_ReadOnly ) ) + { + unsigned char firstByte = file.getch(); + unsigned char secondByte = file.getch(); + unsigned char thirdByte = file.getch(); + if ( firstByte == 0037 && secondByte == 0213 ) + mimetype = "application/x-gzip"; + else if ( firstByte == 'B' && secondByte == 'Z' && thirdByte == 'h' ) + mimetype = "application/x-bzip2"; + else if ( firstByte == 'P' && secondByte == 'K' && thirdByte == 3 ) + { + unsigned char fourthByte = file.getch(); + if ( fourthByte == 4 ) + mimetype = "application/x-zip"; + } + } + } + forced = false; + } + + prepareDevice( filename, mimetype, forced ); +} + +void KIso::prepareDevice( const TQString & filename, + const TQString & mimetype, bool forced ) +{ + /* 'hack' for Qt's false assumption that only S_ISREG is seekable */ + if( "inode/blockdevice" == mimetype ) + setDevice( TQT_TQIODEVICE(new QFileHack( filename )) ); + else + { + if( "application/x-gzip" == mimetype + || "application/x-bzip2" == mimetype) + forced = true; + + TQIODevice *dev = KFilterDev::deviceForFile( filename, mimetype, forced ); + if( dev ) + setDevice( dev ); + } + +} + +KIso::KIso( TQIODevice * dev ) + : KArchive( dev ) +{ + d = new KIsoPrivate; +} + +KIso::~KIso() +{ + // mjarrett: Closes to prevent ~KArchive from aborting w/o device + if( isOpened() ) + close(); + if ( !m_filename.isEmpty() ) + delete device(); // we created it ourselves + delete d; +} + +/* callback function for libisofs */ +static int readf(char *buf, long long start, long long len,void *udata) { + + TQIODevice* dev = ( static_cast<KIso*> (udata) )->device(); + + if (dev->at(start<<11)) { + if ((dev->readBlock(buf, len<<11)) != -1) return (len); + } + kdDebug() << "KIso::ReadRequest failed start: " << start << " len: " << len << endl; + + return -1; +} + +/* callback function for libisofs */ +static int mycallb(struct iso_directory_record *idr,void *udata) { + + KIso *iso = static_cast<KIso*> (udata); + TQString path,user,group,symlink; + int i; + int access; + int time,cdate,adate; + rr_entry rr; + bool special=false; + KArchiveEntry *entry=NULL,*oldentry=NULL; + char z_algo[2],z_params[2]; + long long z_size=0; + + if ((idr->flags[0] & 1) && !iso->showhidden) return 0; + if (iso->level) { + if (isonum_711(idr->name_len)==1) { + switch (idr->name[0]) { + case 0: + path+=("."); + special=true; + break; + case 1: + path+=(".."); + special=true; + break; + } + } + if (iso->showrr && ParseRR(idr,&rr)>0) { + if (!special) path=rr.name; + symlink=rr.sl; + access=rr.mode; + time=rr.t_mtime; + adate=rr.t_atime; + cdate=rr.t_ctime; + user.setNum(rr.uid); + group.setNum(rr.gid); + z_algo[0]=rr.z_algo[0];z_algo[1]=rr.z_algo[1]; + z_params[0]=rr.z_params[0];z_params[1]=rr.z_params[1]; + z_size=rr.z_size; + } else { + access=iso->dirent->permissions() & ~S_IFMT; + adate=cdate=time=isodate_915(idr->date,0); + user=iso->dirent->user(); + group=iso->dirent->group(); + if (idr->flags[0] & 2) access |= S_IFDIR; else access |= S_IFREG; + if (!special) { + if (iso->joliet) { + for (i=0;i<(isonum_711(idr->name_len)-1);i+=2) { + TQChar ch( be2me_16(*((ushort*)&(idr->name[i]))) ); + if (ch==';') break; + path+=ch; + } + } else { + for (i=0;i<isonum_711(idr->name_len);i++) { + if (idr->name[i]==';') break; + if (idr->name[i]) path+=(idr->name[i]); + } + } + if (path.endsWith(".")) path.setLength(path.length()-1); + } + } + if (iso->showrr) FreeRR(&rr); + if (idr->flags[0] & 2) { + entry = new KIsoDirectory( iso, path, access | S_IFDIR, time, adate, cdate, + user, group, symlink ); + } else { + entry = new KIsoFile( iso, path, access, time, adate, cdate, + user, group, symlink, isonum_733(idr->extent)<<11,isonum_733(idr->size) ); + if (z_size) (static_cast <KIsoFile*> (entry))->setZF(z_algo,z_params,z_size); + + } + iso->dirent->addEntry(entry); + } + if ( (idr->flags[0] & 2) && (iso->level==0 || !special) ) { + if (iso->level) { + oldentry=iso->dirent; + iso->dirent=static_cast<KIsoDirectory*> (entry); + } + iso->level++; + ProcessDir(&readf,isonum_733(idr->extent),isonum_733(idr->size),&mycallb,udata); + iso->level--; + if (iso->level) iso->dirent=static_cast<KIsoDirectory*> (oldentry); + } + return 0; +} + +void KIso::addBoot(struct el_torito_boot_descriptor* bootdesc) { + + int i; + long long size; + boot_head boot; + boot_entry *be; + TQString path; + KIsoFile *entry; + + entry=new KIsoFile( this, "Catalog", dirent->permissions() & ~S_IFDIR, + dirent->date(), dirent->adate(), dirent->cdate(), + dirent->user(), dirent->group(), TQString::null, + isonum_731(bootdesc->boot_catalog)<<11, 2048 ); + dirent->addEntry(entry); + if (!ReadBootTable(&readf,isonum_731(bootdesc->boot_catalog),&boot,this)) { + i=1; + be=boot.defentry; + while (be) { + size=BootImageSize( isonum_711((reinterpret_cast<struct default_entry*>(be->data))->media), + isonum_721((reinterpret_cast<struct default_entry*>(be->data))->seccount)); + path="Default Image"; + if (i>1) path += " (" + TQString::number(i) + ")"; + entry=new KIsoFile( this, path, dirent->permissions() & ~S_IFDIR, + dirent->date(), dirent->adate(), dirent->cdate(), + dirent->user(), dirent->group(), TQString::null, + isonum_731((reinterpret_cast<struct default_entry*>(be->data))->start)<<11, size<<9 ); + dirent->addEntry(entry); + be=be->next; + i++; + } + + FreeBootTable(&boot); + } +} + +void KIso::readParams() +{ + TDEConfig *config; + + config = new TDEConfig("kio_isorc"); + + showhidden=config->readBoolEntry("showhidden",false); + showrr=config->readBoolEntry("showrr",true); + delete config; +} + +bool KIso::openArchive( int mode ) +{ + iso_vol_desc *desc; + TQString path,tmp,uid,gid; + struct stat buf; + int tracks[2*100],trackno=0,i,access,c_b,c_i,c_j; + KArchiveDirectory *root; + struct iso_directory_record* idr; + struct el_torito_boot_descriptor* bootdesc; + + if ( mode == IO_WriteOnly ) + return false; + + readParams(); + d->dirList.clear(); + + tracks[0]=0; + if (m_startsec>0) tracks[0]=m_startsec; + kdDebug() << " m_startsec: " << m_startsec << endl; + /* We'll use the permission and user/group of the 'host' file except + * in Rock Ridge, where the permissions are stored on the file system + */ + if (::stat( m_filename.local8Bit(), &buf )<0) { + /* defaults, if stat fails */ + memset(&buf,0,sizeof(struct stat)); + buf.st_mode=0777; + } else { + /* If it's a block device, try to query the track layout (for multisession) */ + if (m_startsec == -1 && S_ISBLK(buf.st_mode)) + trackno=getTracks(m_filename.latin1(),(int*) &tracks); + } + uid.setNum(buf.st_uid); + gid.setNum(buf.st_gid); + access = buf.st_mode & ~S_IFMT; + + kdDebug() << "KIso::openArchive number of tracks: " << trackno << endl; + + if (trackno==0) trackno=1; + for (i=0;i<trackno;i++) { + + c_b=1;c_i=1;c_j=1; + root=rootDir(); + if (trackno>1) { + path=TQString::null; + TQTextOStream(&path) << "Track " << tracks[(i<<1)+1]; + root = new KIsoDirectory( this, path, access | S_IFDIR, + buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, TQString::null ); + rootDir()->addEntry(root); + } + + desc=ReadISO9660(&readf,tracks[i<<1],this); + if (!desc) { + kdDebug() << "KIso::openArchive no volume descriptors" << endl; + continue; + } + + while (desc) { + switch (isonum_711(desc->data.type)) { + case ISO_VD_BOOT: + + bootdesc=(struct el_torito_boot_descriptor*) &(desc->data); + if ( !memcmp(EL_TORITO_ID,bootdesc->system_id,ISODCL(8,39)) ) { + path="El Torito Boot"; + if (c_b>1) path += " (" + TQString::number(c_b) + ")"; + + dirent = new KIsoDirectory( this, path, access | S_IFDIR, + buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, TQString::null ); + root->addEntry(dirent); + + addBoot(bootdesc); + c_b++; + } + break; + + case ISO_VD_PRIMARY: + case ISO_VD_SUPPLEMENTARY: + idr=(struct iso_directory_record*) &( ((struct iso_primary_descriptor*) &desc->data)->root_directory_record); + joliet = JolietLevel(&desc->data); + if (joliet) { + TQTextOStream(&path) << "Joliet level " << joliet; + if (c_j>1) path += " (" + TQString::number(c_j) + ")"; + } else { + path = "ISO9660"; + if (c_i>1) path += " (" + TQString::number(c_i) + ")"; + } + dirent = new KIsoDirectory( this, path, access | S_IFDIR, + buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, TQString::null ); + root->addEntry(dirent); + level=0; + mycallb(idr, this ); + if (joliet) c_j++; else c_i++; + break; + } + desc=desc->next; + } + free(desc); + } + device()->close(); + return true; +} + +bool KIso::closeArchive() +{ + d->dirList.clear(); + return true; +} + +bool KIso::writeDir( const TQString&, const TQString&, const TQString& ) +{ + return false; +} + +bool KIso::prepareWriting( const TQString&, const TQString&, const TQString&, uint) +{ + return false; +} + +bool KIso::doneWriting( uint ) +{ + return false; +} + +void KIso::virtual_hook( int id, void* data ) +{ KArchive::virtual_hook( id, data ); } + |