Security-55163.44.tar.gz

[apple/security.git] / libsecurity_utilities / lib / muscle++.h

diff --git a/libsecurity_utilities/lib/muscle++.h b/libsecurity_utilities/lib/muscle++.h
new file mode 100644 (file)
index 0000000..e79eaf6
--- /dev/null
+++ b/libsecurity_utilities/lib/muscle++.h
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2004 Apple Computer, Inc. All Rights Reserved.
+ * 
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ *
+ */
+
+
+//
+// C++ gate to "Muscle" smartcard interface layer
+//
+// Note: This is written to go together with <pcsc++.h>, rather than stand on
+// its own. It doesn't represent a "all Muscle" view of the card world.
+//
+#ifndef _H_MUSCLE_PP
+#define _H_MUSCLE_PP
+
+#include <security_utilities/refcount.h>
+#include <security_utilities/pcsc++.h>
+#include <PCSC/musclecard.h>
+#include <set>
+
+
+namespace Security {
+namespace Muscle {
+
+
+//
+// Muscle-domain error exceptions
+//
+class Error : public CommonError {
+public:
+       Error(MSC_RV err);
+
+    const MSC_RV error;
+       OSStatus osStatus() const;
+       int unixError() const;
+       const char *what () const throw ();
+       
+       static void check(MSC_RV err) { if (err != MSC_SUCCESS) throwMe(err); }
+       static void throwMe(MSC_RV err);
+};
+
+
+//
+// Unified ACLs of the Muscle kind
+//
+class ACL {
+public:
+       typedef MSCUShort16 Value;
+
+       ACL(Value write = MSC_AUT_ALL, Value read = MSC_AUT_ALL, Value erase = MSC_AUT_ALL);
+
+       ACL() { mRead = mWrite = mErase = MSC_AUT_ALL; }
+       
+       operator MSCKeyACL () const;
+       operator MSCObjectACL () const;
+
+       Value read() const      { return mRead; }
+       bool read(Value mask) const { return mRead & mask; }
+       Value &read()           { return mRead; }
+       Value write() const     { return mWrite; }
+       bool write(Value mask) const { return mWrite & mask; }
+       Value &write()          { return mWrite; }
+       Value erase() const { return mErase; }
+       bool erase(Value mask) const { return mErase & mask; }
+       Value &erase()          { return mErase; }
+       // erase is "use" on keys; they're synonymous
+       Value use() const { return mErase; }
+       bool use(Value mask) const { return mErase & mask; }
+       Value &use()            { return mErase; }
+       
+       string form(char ue) const;
+
+private:
+       MSCUShort16 mRead;
+       MSCUShort16 mWrite;
+       MSCUShort16 mErase;
+};
+
+
+//
+// Muscle item representations (keys and objects unified, the cheap way)
+//
+class CardItem : public RefCount {
+protected:
+       CardItem() { }
+       
+public:
+       virtual ~CardItem();
+       
+       virtual unsigned size() const = 0;
+       virtual const char *name() const = 0;
+
+       virtual const ACL &acl() const = 0;
+       virtual ACL &acl() = 0;
+       
+       virtual void debugDump() = 0;
+       
+       bool operator < (const CardItem &other) const { return this < &other; }
+};
+
+class Key : public CardItem, public MSCKeyInfo {
+public:
+       Key(const MSCKeyInfo &info);
+       
+       unsigned id() const                             { return this->keyNum; }
+       const char *name() const;
+       unsigned type() const                   { return this->keyType; }
+       unsigned size() const;
+       unsigned mode() const                   { return this->keyPolicy.cipherMode; }
+       unsigned operations() const             { return this->keyPolicy.cipherDirection; }
+
+       const ACL &acl() const;
+       ACL &acl();
+       
+       void debugDump();
+
+private:
+       char mKeyName[8];                               // made-up name "Kn"
+};
+
+class Object : public CardItem, public MSCObjectInfo {
+public:
+       Object(const MSCObjectInfo &info) : MSCObjectInfo(info) { }
+
+       const char *name() const;
+       unsigned size() const;
+
+       const ACL &acl() const;
+       ACL &acl();
+       
+       void debugDump();
+};
+
+
+//
+// A Muscle connection to a card.
+// This is NOT a PodWrapper (for MSCTokenConnection or anything else).
+//
+class Transaction;
+
+class Connection : public MSCTokenConnection, public MSCStatusInfo {
+public:
+       Connection();
+       ~Connection();
+       
+       void open(const PCSC::ReaderState &reader, unsigned share = MSC_SHARE_EXCLUSIVE);
+       void close();
+       
+       operator bool () const { return mIsOpen; }
+       
+       void begin(Transaction *trans = NULL);
+       void end(Transaction *trans = NULL);
+       Transaction *currentTransaction() const;
+       
+       typedef set<RefPointer<CardItem> > ItemSet;
+       void getItems(ItemSet &items, bool getKeys = true, bool getOthers = true);
+       
+       void updateStatus();
+       
+private:
+       bool mIsOpen;
+       Transaction *mCurrentTransaction;
+};
+
+
+class Transaction {
+public:
+       Transaction(Connection &con);
+       ~Transaction();
+       
+       Connection &connection;
+};
+
+
+}      // namespace Muscle
+}      // namespace Security
+
+
+#endif //_H_MUSCLE_PP