attributes.cc

   1 // attributes.cc
   2 // Class to manage partition attribute codes. These are binary bit fields,
   3 // of which only four are currently (2/2011) documented on Wikipedia, and
   4 // two others found from other sources.
   5
   6 /* This program is copyright (c) 2009-2011 by Roderick W. Smith. It is distributed
   7   under the terms of the GNU GPL version 2, as detailed in the COPYING file. */
   8
   9 #define __STDC_LIMIT_MACROS
  10 #define __STDC_CONSTANT_MACROS
  11
  12 #include <stdint.h>
  13 #include <stdio.h>
  14 #include <iostream>
  15 #include <sstream>
  16
  17 #include "attributes.h"
  18 #include "support.h"
  19
  20 using namespace std;
  21
  22 string Attributes::atNames[NUM_ATR];
  23 int Attributes::numAttrs = 0;
  24 //Attributes::staticInit Attributes::staticInitializer;
  25
  26 // Default constructor
  27 Attributes::Attributes(void) {
  28    numAttrs++;
  29    if (numAttrs == 1)
  30       Setup();
  31    attributes = 0;
  32 } // constructor
  33
  34 // Alternate constructor
  35 Attributes::Attributes(const uint64_t a) {
  36    numAttrs++;
  37    if (numAttrs == 1)
  38       Setup();
  39    attributes = a;
  40 } // alternate constructor
  41
  42 // Destructor.
  43 Attributes::~Attributes(void) {
  44    numAttrs--;
  45 } // Attributes destructor
  46
  47 void Attributes::Setup(void) {
  48    ostringstream temp;
  49
  50    // Most bits are undefined, so start by giving them an
  51    // appropriate name
  52    for (int i = 0; i < NUM_ATR; i++) {
  53       temp.str("");
  54       temp << "Undefined bit #" << i;
  55       Attributes::atNames[i] = temp.str();
  56    } // for
  57
  58    // Now reset those names that are defined....
  59    atNames[0] = "system partition"; // required for computer to operate
  60    atNames[1] = "hide from EFI";
  61    atNames[2] = "legacy BIOS bootable";
  62    atNames[60] = "read-only";
  63    atNames[62] = "hidden";
  64    atNames[63] = "do not automount";
  65 }  // Attributes::Setup()
  66
  67 // Display current attributes to user
  68 void Attributes::DisplayAttributes(void) {
  69    uint32_t i;
  70    int numSet = 0;
  71
  72    cout << "Attribute value is ";
  73    cout.setf(ios::uppercase);
  74    cout.fill('0');
  75    cout.width(16);
  76    cout << hex << attributes << dec << ". Set fields are:\n";
  77    for (i = 0; i < NUM_ATR; i++) {
  78       if ((UINT64_C(1) << i) & attributes) {
  79          cout << i << " (" << GetAttributeName(i) << ")" << "\n";
  80          numSet++;
  81       } // if
  82    } // for
  83    cout.fill(' ');
  84    if (numSet == 0)
  85       cout << "  No fields set\n";
  86    cout << "\n";
  87 } // Attributes::DisplayAttributes()
  88
  89 // Display attributes for a partition. Note that partNum is just passed for
  90 // immediate display; it's not used to access a particular partition.
  91 void Attributes::ShowAttributes(const uint32_t partNum) {
  92    uint32_t bitNum;
  93    bool bitset;
  94
  95    for (bitNum = 0; bitNum < 64; bitNum++) {
  96       bitset = (UINT64_C(1) << bitNum) & attributes;
  97       if (bitset) {
  98          cout << partNum+1 << ":" << bitNum << ":" << bitset
  99          << " (" << GetAttributeName(bitNum) << ")" << endl;
 100       } // if
 101    } // for
 102 } // Attributes::ShowAttributes
 103
 104 // Prompt user for attribute changes
 105 void Attributes::ChangeAttributes(void) {
 106    int response;
 107    uint64_t bitValue;
 108
 109    cout << "Known attributes are:\n";
 110    ListAttributes();
 111    cout << "\n";
 112
 113    do {
 114       DisplayAttributes();
 115       response = GetNumber(0, NUM_ATR, 64,
 116                            "Toggle which attribute field (0-63, 64 or <Enter> to exit): ");
 117       if (response != 64) {
 118          bitValue = UINT64_C(1) << response; // Find the integer value of the bit
 119          if (bitValue & attributes) { // bit is set
 120             attributes &= ~bitValue; // so unset it
 121                  cout << "Have disabled the '" << atNames[response] << "' attribute.\n";
 122          } else { // bit is not set
 123             attributes |= bitValue; // so set it
 124             cout << "Have enabled the '" << atNames[response] << "' attribute.\n";
 125          } // if/else
 126       } // if
 127    } while (response != 64);
 128 } // Attributes::ChangeAttributes()
 129
 130 // Display all defined attributes on the screen (omits undefined bits).
 131 void Attributes::ListAttributes(void) {
 132    uint32_t bitNum;
 133    string tempAttr;
 134
 135    for (bitNum = 0; bitNum < NUM_ATR; bitNum++) {
 136       tempAttr = GetAttributeName(bitNum);
 137       if (tempAttr.substr(0, 15) != "Undefined bit #" )
 138          cout << bitNum << ": " << Attributes::GetAttributeName(bitNum) << "\n";
 139    } // for
 140 } // Attributes::ListAttributes
 141
 142 // multifaceted attributes access
 143 // returns true upon success, false upon failure
 144 bool Attributes::OperateOnAttributes(const uint32_t partNum, const string& attributeOperator, const string& attributeBits) {
 145
 146    // attribute access opcode
 147    typedef enum {
 148       ao_or, ao_nand, ao_xor, ao_assignall,  // operate on all attributes (bitmask)
 149       ao_unknown, // must be after bitmask operators and before bitnum operators
 150       ao_set, ao_clear, ao_toggle, ao_get    // operate on a single attribute (bitnum)
 151    } attribute_opcode_t; // typedef enum
 152
 153    // translate attribute operator into an attribute opcode
 154    attribute_opcode_t attributeOpcode = ao_unknown; { // opcode is not known yet
 155       if      (attributeOperator == "or")      attributeOpcode = ao_or;
 156       else if (attributeOperator == "nand")    attributeOpcode = ao_nand;
 157       else if (attributeOperator == "xor")     attributeOpcode = ao_xor;
 158       else if (attributeOperator == "=")       attributeOpcode = ao_assignall;
 159       else if (attributeOperator == "set")     attributeOpcode = ao_set;
 160       else if (attributeOperator == "clear")   attributeOpcode = ao_clear;
 161       else if (attributeOperator == "toggle")  attributeOpcode = ao_toggle;
 162       else if (attributeOperator == "get")     attributeOpcode = ao_get;
 163       else {
 164          cerr << "Unknown attributes operator: " << attributeOperator << endl;
 165          return false;
 166       } // else
 167    } // attributeOpcode
 168
 169    // get bit mask if operating on entire attribute set
 170    uint64_t attributeBitMask; { if (attributeOpcode < ao_unknown) {
 171       if (1 != sscanf (attributeBits.c_str(), "%qx", (long long unsigned int*) &attributeBitMask)) {
 172          cerr << "Could not convert hex attribute mask" << endl;
 173          return false;
 174       } // if
 175    }} // attributeBitMask, if
 176
 177    // get bit number and calculate bit mask if operating on a single attribute
 178    int bitNum; { if (attributeOpcode > ao_unknown) {
 179       if (1 != sscanf (attributeBits.c_str(), "%d", &bitNum)) {
 180          cerr << "Could not convert bit number" << endl;
 181          return false;
 182       } // if
 183       const uint64_t one = 1;
 184       attributeBitMask = one << bitNum;
 185    }} // bitNum, if
 186
 187    switch (attributeOpcode) {
 188       // assign all attributes at once
 189       case ao_assignall:  attributes = attributeBitMask;    break;
 190
 191       // set individual attribute(s)
 192       case ao_set:
 193       case ao_or:         attributes |= attributeBitMask;   break;
 194
 195       // clear individual attribute(s)
 196       case ao_clear:
 197       case ao_nand:       attributes &= ~attributeBitMask;  break;
 198
 199       // toggle individual attribute(s)
 200       case ao_toggle:
 201       case ao_xor:        attributes ^= attributeBitMask;   break;
 202
 203       // display a single attribute
 204       case ao_get: {
 205          cout << partNum+1 << ":" << bitNum << ":"
 206               << bool (attributeBitMask & attributes) << endl;
 207          break;
 208       } // case ao_get
 209
 210       default: break; // will never get here
 211    } // switch
 212
 213    return true;
 214 } // Attributes::OperateOnAttributes()
 215
 216 /*******************************
 217 *                             *
 218 * Non-class support functions *
 219 *                             *
 220 *******************************/
 221
 222 // Display attributes
 223 ostream & operator<<(ostream & os, const Attributes & data) {
 224    os << data.GetAttributes();
 225    return os;
 226 } // operator<<()