00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include "SecurityServer.hh"
00028 #include "PrettyDebug.hh"
00029
00030 #include <cassert>
00031
00032 using std::list ;
00033 using std::endl ;
00034
00035 static pdCDebug D("SECURITY_SERVER", __FILE__);
00036 static PrettyDebug G("GENDOC",__FILE__);
00037
00038 namespace certi {
00039
00040
00044 Socket*
00045 SecurityServer::getSocketLink(FederateHandle theFederate,
00046 TransportType theType) const
00047 {
00048
00049 Socket * sock = RTIG_SocketServer.getSocketLink(myFederation, theFederate, theType);
00050 if ( sock == NULL )
00051
00052 return NULL ;
00053 else
00054 return sock ;
00055 }
00056
00057
00059 bool
00060 SecurityServer::dominates(SecurityLevelID A, SecurityLevelID B) const
00061 {
00062 return A == B || B == PublicLevelID ;
00063 }
00064
00065
00072 bool
00073 SecurityServer::canFederateAccessData(FederateHandle theFederate,
00074 SecurityLevelID theDataLevelID)
00075 {
00076 Socket *FederateSocket=NULL;
00077 SecureTCPSocket *SecureSocket=NULL;
00078
00079 const char *FederateName ;
00080 SecurityLevelID FederateLevel ;
00081
00082
00083
00084 try {
00085 FederateSocket = getSocketLink(theFederate);
00086 }
00087 catch (RTIinternalError &e) {
00088 return dominates(PublicLevelID, theDataLevelID);
00089 }
00090
00091
00092 if (NULL!=FederateSocket) {
00093 SecureSocket = dynamic_cast<SecureTCPSocket *>(FederateSocket);
00094 }
00095
00096 if (NULL==SecureSocket) {
00097
00098 return dominates(PublicLevelID, theDataLevelID);
00099 }
00100
00101
00102 FederateName = SecureSocket->getPeerName();
00103
00104
00105 FederateLevel = getLevel(FederateName);
00106
00107 return dominates(FederateLevel, theDataLevelID);
00108 }
00109
00110
00112 SecurityServer::SecurityServer(SocketServer &theRTIGServer,
00113 AuditFile &theAuditServer,
00114 Handle theFederation)
00115 : list<SecurityLevel *>(), audit(theAuditServer),
00116 RTIG_SocketServer(theRTIGServer)
00117 {
00118 myFederation = theFederation ;
00119
00120 if (myFederation == 0)
00121 throw RTIinternalError("");
00122 }
00123
00124
00126 SecurityServer::~SecurityServer()
00127 {
00128 while (!empty()) {
00129 delete front();
00130 pop_front();
00131 }
00132 }
00133
00134
00136 SecurityLevelID
00137 SecurityServer::getLevel(const char *theFederate) const
00138 {
00139 return FedLevelList.getLevel(theFederate);
00140 }
00141
00142
00144 SecurityLevelID
00145 SecurityServer::getLevelIDWithName(const char *theName)
00146 {
00147 if (empty()) {
00148 D[pdDebug] << "Empty list: added default (public) level" << endl ;
00149 insertPublicLevel();
00150 }
00151
00152 if ((theName == NULL) || (strlen(theName) > MAX_SECURITYLEVELNAME)) {
00153 D[pdDebug] << "Security Level Name null or too long." << endl ;
00154 throw RTIinternalError("Security Level Name null or too long.");
00155 }
00156
00157 list<SecurityLevel *>::const_iterator i = begin();
00158 for (; i != end(); i++) {
00159 if (strcmp((*i)->Name, theName) == 0)
00160 return (*i)->LevelID ;
00161 }
00162
00163
00164 D[pdDebug] << "Level " << theName << " not found. Adding it to the list."
00165 << endl ;
00166 LastLevelID ++ ;
00167 SecurityLevel *StoredLevel = new SecurityLevel(theName, LastLevelID);
00168 push_back(StoredLevel);
00169
00170 return LastLevelID ;
00171 }
00172
00173
00175 void
00176 SecurityServer::insertPublicLevel()
00177 {
00178 SecurityLevel *PublicLevel ;
00179
00180 PublicLevel = new SecurityLevel(PublicLevelName, PublicLevelID);
00181 assert(PublicLevel != NULL);
00182
00183 push_front(PublicLevel);
00184
00185 LastLevelID = PublicLevelID ;
00186 }
00187
00188
00190 void
00191 SecurityServer::registerFederate(const char *the_federate,
00192 SecurityLevelID the_level_id)
00193 {
00194 FedLevelList.addFederate(the_federate, the_level_id);
00195 }
00196
00197 }
00198
00199