FryingPan/ISOBuilder/RRStructures.cpp

   1 /*
   2  * FryingPan - Amiga CD/DVD Recording Software (User Interface and supporting Libraries only)
   3  * Copyright (C) 2001-2011 Tomasz Wiszkowski Tomasz.Wiszkowski at gmail.com
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public License
   7  * as published by the Free Software Foundation; either version 2.1
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "RRStructures.h"
  21 #include "ISOStructures.h"
  22 #include <LibC/LibC.h>
  23
  24 RRExt::RRExt(uint8 id1, uint8 id2, uint8 flags, uint8 sets)
  25 {
  26    this->id[0] =  id1;
  27    this->id[1] =  id2;
  28    this->flags =  flags;
  29    this->sets  =  sets;
  30 }
  31
  32 RRExt::~RRExt()
  33 {
  34 };
  35
  36 uint8 RRExt::Length()
  37 {
  38    return 5;
  39 }
  40
  41 uint8* RRExt::PutData(uint8* loc)
  42 {
  43    *loc++ = id[0];
  44    *loc++ = id[1];
  45    *loc++ = Length();
  46    *loc++ = 1;
  47
  48    if (sets & Set_Flags)
  49       *loc++ = flags;
  50
  51    return loc;
  52 };
  53
  54 void RRExt::SetFlags(uint8 flags)
  55 {
  56    this->flags = flags;
  57 }
  58
  59 uint8 RRExt::GetFlags()
  60 {
  61    return flags;
  62 }
  63
  64
  65 RR_NM::RR_NM(const char* name) :
  66    RRExt('N', 'M')
  67 {
  68    SetName(name);
  69 };
  70
  71 void RR_NM::SetName(const char* name)
  72 {
  73    this->name = name;
  74 }
  75
  76 uint8 RR_NM::Length()
  77 {
  78    return RRExt::Length()+name.Length();
  79 }
  80
  81 uint8 *RR_NM::PutData(uint8* loc)
  82 {
  83    loc = RRExt::PutData(loc);
  84    strncpy((char*)loc, name.Data(), name.Length());
  85    loc += name.Length();
  86    return loc;
  87 }
  88
  89
  90 RR_RR::RR_RR(uint8 flags) :
  91    RRExt('R', 'R', flags)
  92 {
  93 };
  94
  95
  96 RR_AS::RR_AS(const char* comment, uint8 protection) :
  97    RRExt('A', 'S')
  98 {
  99    this->comment     = comment;
 100    this->protection  = protection;
 101 }
 102
 103 uint8 RR_AS::Length()
 104 {
 105    uint8 size = 0;
 106    uint8 flags = 0;
 107
 108    size = comment.Length();
 109    if (size != 0)
 110    {
 111       size++;
 112       flags |= 2;
 113    }
 114
 115    if (protection != 0)
 116    {
 117       size += 4;
 118       flags |= 1;
 119    }
 120
 121    RRExt::SetFlags(flags);
 122    if (flags == 0)
 123       return 0;
 124
 125    return RRExt::Length() + size;
 126 }
 127
 128 uint8 *RR_AS::PutData(uint8* loc)
 129 {
 130    uint8 flags = RRExt::GetFlags();
 131
 132    if (flags == 0)
 133       return loc;
 134
 135    loc = RRExt::PutData(loc);
 136
 137    if (flags & 1)
 138    {
 139       *loc++ = 0;
 140       *loc++ = 0;
 141       *loc++ = 0;
 142       *loc++ = protection;
 143    }
 144
 145    if (flags & 2)
 146    {
 147       *loc++   = comment.Length()+1;
 148       strncpy((char*)loc, comment.Data(), comment.Length());
 149       loc += comment.Length();
 150    }
 151
 152    return loc;
 153 }
 154
 155 void RR_AS::SetFlags(uint8 flags)
 156 {
 157    protection = flags;
 158 }
 159
 160 void RR_AS::SetElemComment(const char* comment)
 161 {
 162    this->comment = comment;
 163 }
 164
 165 const String &RR_AS::GetElemComment() const
 166 {
 167    return comment;
 168 }
 169
 170
 171 RR_SP::RR_SP() :
 172    RRExt('S', 'P')
 173 {
 174 }
 175
 176 uint8 RR_SP::Length()
 177 {
 178    return 7;
 179 }
 180
 181 uint8 *RR_SP::PutData(uint8* loc)
 182 {
 183    *loc++ = 'S';
 184    *loc++ = 'P';
 185    *loc++ = 7;
 186    *loc++ = 1;
 187    *loc++ = 0xBE;
 188    *loc++ = 0xEF;
 189    *loc++ = 0x00;
 190    return loc;
 191 }
 192
 193
 194 RR_PX::RR_PX(uint8 prot, bool dir) :
 195    RRExt('P', 'X')
 196 {
 197    SetFlags(prot);
 198    SetDir(dir);
 199 }
 200
 201 uint8 RR_PX::Length()
 202 {
 203    return 44;
 204 }
 205
 206 uint8 *RR_PX::PutData(uint8* loc)
 207 {
 208    val733 *v;
 209
 210    *loc++ = 'P';
 211    *loc++ = 'X';
 212    *loc++ = 44;
 213    *loc++ = 1;
 214    v = (val733*)loc;
 215    v->setVal(flags);
 216    loc += sizeof(val733);
 217
 218    v = (val733*)loc;
 219    v->setVal(0);
 220    loc += sizeof(val733);
 221
 222    v = (val733*)loc;
 223    v->setVal(0);
 224    loc += sizeof(val733);
 225
 226    v = (val733*)loc;
 227    v->setVal(0);
 228    loc += sizeof(val733);
 229
 230    v = (val733*)loc;
 231    v->setVal(0);
 232    loc += sizeof(val733);
 233
 234    return loc;
 235 }
 236
 237 void RR_PX::SetFlags(uint8 p)
 238 {
 239    prot = p;
 240
 241    flags = 0;
 242
 243    if ((prot & 8) == 0)
 244       flags |= S_IROTH | S_IRGRP | S_IRUSR;
 245    if ((prot & 4) == 0)
 246       flags |= S_IWOTH | S_IWGRP | S_IWUSR;
 247    if ((prot & 2) == 0)
 248       flags |= S_IXOTH | S_IXGRP | S_IXUSR;
 249
 250    if (dir)
 251       flags |= S_IFDIR;
 252    else
 253       flags |= S_IFREG;
 254 }
 255
 256 uint8 RR_PX::GetFlags()
 257 {
 258    return prot;
 259 }
 260
 261 void RR_PX::SetDir(bool dir)
 262 {
 263    this->dir = dir;
 264
 265    flags &= ~(S_IFDIR | S_IFREG);
 266    if (dir)
 267       flags |= S_IFDIR;
 268    else
 269       flags |= S_IFREG;
 270 }
 271
 272 /*
 273  * RR_CE: content extension entry
 274  * no flags
 275  */
 276 RR_CE::RR_CE() :
 277    RRExt('C', 'E', 0, 0)
 278 {
 279 }
 280
 281 void RR_CE::setBlock(uint32 block)
 282 {
 283    this->block = (block);
 284 }
 285
 286 void RR_CE::setOffset(uint32 offset)
 287 {
 288    this->offset = (offset);
 289 }
 290
 291 void RR_CE::setLength(uint32 length)
 292 {
 293    this->length = (length);
 294 }
 295
 296 uint8 RR_CE::Length()
 297 {
 298    return 28;
 299 }
 300
 301 uint8 *RR_CE::PutData(uint8* loc)
 302 {
 303    val733 *v;
 304
 305    loc = RRExt::PutData(loc);
 306
 307    v = (val733*)loc;
 308    v->setVal(block);
 309    v++;
 310    v->setVal(offset);
 311    v++;
 312    v->setVal(length);
 313
 314    return (uint8*) v;
 315 }
 316
 317
 318