1024 lines
27 KiB
C++
1024 lines
27 KiB
C++
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
iismeta.cxx
|
|
|
|
Abstract:
|
|
|
|
Test for Mapper DLL list management
|
|
|
|
Author:
|
|
|
|
Philippe Choquier (phillich) 03-july-1996
|
|
|
|
--*/
|
|
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <wincrypt.h>
|
|
#include <xbf.hxx>
|
|
#include <immd5.h>
|
|
#include <iismap.hxx>
|
|
#include <iiscmr.hxx>
|
|
|
|
#define DBL_CHAR_CMD(a,b) (((a)<<8)|(b))
|
|
#define AscToHex(a) ( (a)>='a' ? ((a)-'a'+10) : ((a)>='A' ? (a)-'A'+10 : (a)-'0') )
|
|
|
|
char HEXTOA[] = "0123456789abcdef";
|
|
|
|
typedef struct _BinaryObject {
|
|
LPBYTE pB;
|
|
UINT cB;
|
|
} BinaryObject;
|
|
|
|
class UnivMap {
|
|
public:
|
|
BOOL Init( CIisAcctMapper *pM ) { pMap = pM; BOOL f; return pMap->Unserialize(); }
|
|
BOOL Load() { return pMap->Load(); }
|
|
BOOL Terminate() { return TRUE; }
|
|
BOOL Save() { return pMap->Save() && pMap->Serialize(); }
|
|
BOOL List();
|
|
BOOL LocateBase( LPSTR*, DWORD );
|
|
//
|
|
//CIisMapping* CreateNewMapping() { return pMap->CreateNewMapping(); }
|
|
virtual BOOL Map( LPSTR* ) { return FALSE; }
|
|
virtual BOOL Add( LPSTR* ) { return FALSE; }
|
|
virtual BOOL AddBinary( BinaryObject*, UINT ) { return FALSE; }
|
|
virtual BOOL Locate( LPSTR* ) { return FALSE; }
|
|
virtual BOOL IsBinary() { return FALSE; }
|
|
virtual BOOL IsBinary( DWORD ) { return FALSE; }
|
|
virtual LPSTR SubjectFieldDisplay() { return FALSE; }
|
|
virtual BOOL SubjectFieldSet( LPSTR ) { return FALSE; }
|
|
virtual LPSTR DomainDisplay() { return FALSE; }
|
|
virtual BOOL DomainSet( LPSTR ) { return FALSE; }
|
|
BOOL ListCurrent();
|
|
BOOL DeleteCurrent() { return m_iCurrent == 0xffffffff ? FALSE : pMap->Delete( m_iCurrent ); }
|
|
BOOL SetCurrent( DWORD dwC )
|
|
{ if ( dwC < pMap->GetNbMapping() )
|
|
{m_iCurrent = dwC; return TRUE;}
|
|
else {return FALSE;} }
|
|
protected:
|
|
CIisAcctMapper *pMap;
|
|
CIisMapping *pMapping;
|
|
DWORD m_iCurrent;
|
|
} ;
|
|
|
|
|
|
class CertMap : public UnivMap {
|
|
public:
|
|
BOOL IsBinary() { return FALSE; }
|
|
BOOL Map( LPSTR* );
|
|
BOOL Add( LPSTR* );
|
|
BOOL Locate( LPSTR* pF ) { return LocateBase( pF, IISMDB_INDEX_NB ); }
|
|
} ;
|
|
|
|
|
|
class Cert11Map : public UnivMap {
|
|
public:
|
|
BOOL IsBinary() { return TRUE; }
|
|
BOOL Map( LPSTR* );
|
|
BOOL Add( LPSTR* );
|
|
BOOL AddBinary( BinaryObject*, UINT );
|
|
BOOL Locate( LPSTR* pF )
|
|
{ return LocateBase( pF, IISMDB_INDEX_CERT11_NB ); }
|
|
BOOL IsBinary( DWORD i )
|
|
{ return i != IISMDB_INDEX_CERT11_NT_ACCT; }
|
|
LPSTR SubjectFieldDisplay()
|
|
{ return ((CIisCert11Mapper*)pMap)->GetSubjectSource(); }
|
|
BOOL SubjectFieldSet( LPSTR psz )
|
|
{ return ((CIisCert11Mapper*)pMap)->SetSubjectSource(psz); }
|
|
LPSTR DomainDisplay()
|
|
{ return ((CIisCert11Mapper*)pMap)->GetDefaultDomain(); }
|
|
BOOL DomainSet( LPSTR psz )
|
|
{ return ((CIisCert11Mapper*)pMap)->SetDefaultDomain(psz); }
|
|
} ;
|
|
|
|
|
|
class ItaMap : public UnivMap {
|
|
public:
|
|
BOOL IsBinary() { return FALSE; }
|
|
BOOL Map( LPSTR* );
|
|
BOOL Add( LPSTR* );
|
|
BOOL Locate( LPSTR* pF ) { return LocateBase( pF, IISIMDB_INDEX_NB ); }
|
|
} ;
|
|
|
|
|
|
class Md5Map : public UnivMap {
|
|
public:
|
|
BOOL IsBinary() { return FALSE; }
|
|
BOOL Map( LPSTR* );
|
|
BOOL Add( LPSTR* );
|
|
BOOL Locate( LPSTR* pF ) { return LocateBase( pF, IISMMDB_INDEX_NB ); }
|
|
};
|
|
|
|
|
|
BOOL
|
|
UnivMap::List(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD iM = pMap->GetNbMapping();
|
|
|
|
for ( i = 0 ; i < iM ; ++i )
|
|
{
|
|
m_iCurrent = i;
|
|
ListCurrent();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
UnivMap::ListCurrent(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD i;
|
|
CIisMapping *pI;
|
|
DWORD cF;
|
|
IISMDB_Fields *pFi;
|
|
|
|
|
|
if ( m_iCurrent == 0xffffffff )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
printf( "%5d: ", m_iCurrent + 1 );
|
|
|
|
pMap->MappingGetFieldList( &pFi, &cF );
|
|
|
|
if ( pMap->GetMapping( m_iCurrent, &pI ) )
|
|
{
|
|
for ( DWORD i = 0 ; i < cF ; ++i )
|
|
{
|
|
LPSTR pS;
|
|
DWORD dwS;
|
|
LPSTR pAllocS = NULL;
|
|
UINT x;
|
|
|
|
if ( IsBinary() )
|
|
{
|
|
#if defined(DISPLAY_UUENCODED )
|
|
|
|
pI->MappingGetField( i, &pS, &dwS, IsBinary(i) );
|
|
if ( IsBinary(i)
|
|
&& dwS == sizeof("Kj==")-1
|
|
&& !memcmp( pS, "Kj==", sizeof("Kj==")-1 ) )
|
|
{
|
|
pS = "*";
|
|
dwS = 1;
|
|
}
|
|
#else
|
|
|
|
pI->MappingGetField( i, &pS, &dwS, FALSE );
|
|
if ( IsBinary(i) )
|
|
{
|
|
pAllocS = (LPSTR)LocalAlloc( LMEM_FIXED, dwS*2 );
|
|
for ( x = 0 ; x < dwS ; ++x )
|
|
{
|
|
pAllocS[x*2] = HEXTOA[ ((LPBYTE)pS)[x]>>4 ];
|
|
pAllocS[x*2+1] = HEXTOA[ ((LPBYTE)pS)[x] & 0x0f ];
|
|
}
|
|
dwS *= 2;
|
|
pS = pAllocS;
|
|
}
|
|
|
|
#endif
|
|
printf( "%*.*s%s", dwS, dwS, pS, i==cF-1 ? "\n" : ", " );
|
|
if ( pAllocS != NULL )
|
|
{
|
|
LocalFree( pAllocS );
|
|
pAllocS = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pI->MappingGetField( i, &pS );
|
|
printf( "%s%s", pS, i==cF-1 ? "\n" : ", " );
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
UnivMap::LocateBase(
|
|
LPSTR* pF,
|
|
DWORD cF
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD iM = pMap->GetNbMapping();
|
|
CIisMapping *pI;
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
for ( i = 0 ; i < cF ; ++i )
|
|
{
|
|
if ( pF[i] == NULL )
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
pMap->DeleteMappingObject( pMapping );
|
|
return FALSE;
|
|
}
|
|
pMapping->MappingSetField( i, pF[i] );
|
|
}
|
|
|
|
for ( i = 0 ; i < iM ; ++i )
|
|
{
|
|
if ( pMap->GetMapping( i, &pI ) )
|
|
{
|
|
DWORD iF;
|
|
for ( iF = 0 ; iF < cF ; ++iF )
|
|
{
|
|
LPSTR pS1;
|
|
LPSTR pS2;
|
|
pMapping->MappingGetField( iF, &pS1 );
|
|
pI->MappingGetField( iF, &pS2 );
|
|
if ( strcmp( pS1, pS2 ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if ( iF == cF )
|
|
{
|
|
m_iCurrent = i;
|
|
pMap->DeleteMappingObject( pMapping );
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
pMap->DeleteMappingObject( pMapping );
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CertMap::Map(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
CIisMapping* pMi;
|
|
|
|
if ( !pF[0] || !pF[1] || !pF[2] || !pF[3] || !pF[4] || !pF[5] || !pF[6] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
pMapping->MappingSetField( IISMDB_INDEX_ISSUER_O, pF[0] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_ISSUER_OU, pF[1] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_ISSUER_C, pF[2] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_O, pF[3] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_OU, pF[4] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_C, pF[5] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_CN, pF[6] );
|
|
|
|
m_iCurrent = 0xffffffff;
|
|
fSt = pMap->FindMatch( pMapping, &pMi, &m_iCurrent );
|
|
pMap->DeleteMappingObject( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CertMap::Add(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
|
|
if ( !pF[0] || !pF[1] || !pF[2] || !pF[3] || !pF[4] || !pF[5] || !pF[6] || !pF[7] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
pMapping->MappingSetField( IISMDB_INDEX_ISSUER_O, pF[0] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_ISSUER_OU, pF[1] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_ISSUER_C, pF[2] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_O, pF[3] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_OU, pF[4] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_C, pF[5] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_SUBJECT_CN, pF[6] );
|
|
pMapping->MappingSetField( IISMDB_INDEX_NT_ACCT, pF[7] );
|
|
|
|
fSt = pMap->Add( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
Cert11Map::Map(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
CIisMapping* pMi;
|
|
|
|
if ( !pF[0]
|
|
#if !defined(CERT11_FULL_CERT)
|
|
|| !pF[1]
|
|
#endif
|
|
)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
#if defined(CERT11_FULL_CERT)
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_CERT, pF[0], strlen(pF[0]), TRUE );
|
|
#else
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_SUBJECT, pF[0], strlen(pF[0]), TRUE );
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_ISSUER, pF[1], strlen(pF[1]), TRUE );
|
|
#endif
|
|
m_iCurrent = 0xffffffff;
|
|
fSt = pMap->FindMatch( pMapping, &pMi, &m_iCurrent );
|
|
pMap->DeleteMappingObject( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
Cert11Map::Add(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
|
|
if ( !pF[0] || !pF[1]
|
|
#if !defined(CERT11_FULL_CERT)
|
|
|| !pF[2]
|
|
#endif
|
|
)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
#if defined(CERT11_FULL_CERT)
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_CERT, pF[0], strlen(pF[0]), TRUE );
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_NT_ACCT, pF[1], strlen(pF[1]), FALSE );
|
|
#else
|
|
// if subject is '*' store it as is ( it is not uuencoded )
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_SUBJECT,
|
|
pF[0],
|
|
strlen(pF[0]),
|
|
strcmp( pF[0], "*") ? TRUE : FALSE );
|
|
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_ISSUER, pF[1], strlen(pF[1]), TRUE );
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_NT_ACCT, pF[2], strlen(pF[2]), FALSE );
|
|
#endif
|
|
|
|
fSt = pMap->Add( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
Cert11Map::AddBinary(
|
|
BinaryObject* pF,
|
|
UINT cF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
|
|
if ( cF != 2 )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_CERT, (LPSTR)pF[0].pB, pF[0].cB, FALSE );
|
|
pMapping->MappingSetField( IISMDB_INDEX_CERT11_NT_ACCT, (LPSTR)pF[1].pB, pF[1].cB, FALSE );
|
|
|
|
fSt = pMap->Add( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
Md5Map::Map(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
CIisMapping* pMi;
|
|
|
|
if ( !pF[0] || !pF[1] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
pMapping->MappingSetField( IISMMDB_INDEX_IT_REALM, pF[0] );
|
|
pMapping->MappingSetField( IISMMDB_INDEX_IT_ACCT, pF[1] );
|
|
|
|
m_iCurrent = 0xffffffff;
|
|
fSt = pMap->FindMatch( pMapping, &pMi, &m_iCurrent );
|
|
pMap->DeleteMappingObject( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
Md5Map::Add(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
|
|
if ( !pF[0] || !pF[1] || !pF[2] || !pF[3] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
pMapping->MappingSetField( IISMMDB_INDEX_IT_REALM, pF[0] );
|
|
pMapping->MappingSetField( IISMMDB_INDEX_IT_ACCT, pF[1] );
|
|
pMapping->MappingSetField( IISMMDB_INDEX_IT_MD5PWD, pF[2] );
|
|
pMapping->MappingSetField( IISMMDB_INDEX_NT_ACCT, pF[3] );
|
|
|
|
fSt = pMap->Add( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ItaMap::Map(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
CIisMapping* pMi;
|
|
|
|
if ( !pF[0] || !pF[1] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
pMapping->MappingSetField( IISIMDB_INDEX_IT_ACCT, pF[0] );
|
|
pMapping->MappingSetField( IISIMDB_INDEX_IT_PWD, pF[1] );
|
|
|
|
m_iCurrent = 0xffffffff;
|
|
fSt = pMap->FindMatch( pMapping, &pMi, &m_iCurrent );
|
|
pMap->DeleteMappingObject( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ItaMap::Add(
|
|
LPSTR* pF
|
|
)
|
|
{
|
|
BOOL fSt = FALSE;
|
|
|
|
if ( !pF[0] || !pF[1] || !pF[2] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pMapping = pMap->CreateNewMapping() )
|
|
{
|
|
pMapping->MappingSetField( IISIMDB_INDEX_IT_ACCT, pF[0] );
|
|
pMapping->MappingSetField( IISIMDB_INDEX_IT_PWD, pF[1] );
|
|
pMapping->MappingSetField( IISIMDB_INDEX_NT_ACCT, pF[2] );
|
|
|
|
fSt = pMap->Add( pMapping );
|
|
pMapping = NULL;
|
|
}
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
CIisCertMapper mpCert;
|
|
CIisCert11Mapper mpCert11;
|
|
CIisItaMapper mpIta;
|
|
CIisMd5Mapper mpMd5;
|
|
|
|
CertMap umCert;
|
|
Cert11Map umCert11;
|
|
ItaMap umIta;
|
|
Md5Map umMd5;
|
|
|
|
#if 0
|
|
CIssuerStore isIssuers1;
|
|
CIssuerStore isIssuers2;
|
|
CIisRuleMapper irmRules1;
|
|
CIisRuleMapper irmRules2;
|
|
CStoreXBF ser(1024);
|
|
|
|
|
|
BYTE RuleElem1[] = "\x1" "VeriSign";
|
|
BYTE RuleElem2[] = "\x2" "VeriSign";
|
|
|
|
|
|
void
|
|
testcmr(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD dwI;
|
|
CCertMapRule *pR;
|
|
LPBYTE pContent;
|
|
DWORD cContent;
|
|
LPSTR pID;
|
|
LPSTR pMatch;
|
|
LPBYTE pBin;
|
|
DWORD dwBin;
|
|
|
|
isIssuers1.LoadServerAcceptedIssuers();
|
|
isIssuers1.Serialize( &ser );
|
|
isIssuers2.Unserialize( &ser );
|
|
|
|
isIssuers2.GetIssuer( 2, &pID, &pContent, &cContent );
|
|
isIssuers2.GetIssuerByName( pID, &pContent, &cContent );
|
|
|
|
// 1st rule
|
|
|
|
dwI = irmRules1.AddRule();
|
|
pR = irmRules1.GetRule( dwI );
|
|
printf( "%d\n", irmRules1.GetRuleCount() );
|
|
|
|
pR->SetRuleName( "Rule1" );
|
|
pR->SetRuleAccount( "Account" );
|
|
pR->SetRuleDenyAccess( FALSE );
|
|
pR->SetRuleEnabled( TRUE );
|
|
pR->AddRuleElem( 0xffffffff,
|
|
CERT_FIELD_ISSUER,
|
|
irmRules1.MapSubFieldToAsn1( "OU" ),
|
|
RuleElem1,
|
|
sizeof(RuleElem1)-1 );
|
|
pR->AddRuleElem( 0xffffffff,
|
|
CERT_FIELD_ISSUER,
|
|
irmRules1.MapSubFieldToAsn1( "O" ),
|
|
RuleElem1,
|
|
sizeof(RuleElem1)-1 );
|
|
pR->DeleteRuleElem( 0 );
|
|
pR->SetMatchAllIssuer( TRUE );
|
|
|
|
ser.Clear();
|
|
pR->Serialize( &ser );
|
|
pR->Unserialize( &ser );
|
|
|
|
// 2nd rule
|
|
|
|
dwI = irmRules1.AddRule();
|
|
pR = irmRules1.GetRule( dwI );
|
|
pR->SetRuleName( "Rule2" );
|
|
pR->SetRuleAccount( "Account2" );
|
|
pR->SetRuleDenyAccess( FALSE );
|
|
pR->SetRuleEnabled( TRUE );
|
|
pR->AddRuleElem( 0xffffffff,
|
|
CERT_FIELD_ISSUER,
|
|
irmRules1.MapSubFieldToAsn1( "OU" ),
|
|
RuleElem2,
|
|
sizeof(RuleElem2)-1 );
|
|
pR->AddRuleElem( 0xffffffff,
|
|
CERT_FIELD_ISSUER,
|
|
irmRules1.MapSubFieldToAsn1( "O" ),
|
|
RuleElem2,
|
|
sizeof(RuleElem2)-1 );
|
|
pR->SetMatchAllIssuer( FALSE );
|
|
pR->AddIssuerEntry( pID, TRUE );
|
|
|
|
irmRules1.Save( "a" );
|
|
irmRules2.Load( "a" );
|
|
pR = irmRules2.GetRule( 1 );
|
|
printf( "%s\n", pR->GetRuleName() );
|
|
|
|
irmRules1.MatchRequestToBinary( "*first", &pBin, &dwBin );
|
|
irmRules1.BinaryToMatchRequest( pBin, dwBin, &pMatch );
|
|
irmRules1.FreeMatchConversion( pBin );
|
|
irmRules1.FreeMatchConversion( pMatch );
|
|
|
|
irmRules1.MatchRequestToBinary( "last*", &pBin, &dwBin );
|
|
irmRules1.BinaryToMatchRequest( pBin, dwBin, &pMatch );
|
|
irmRules1.FreeMatchConversion( pBin );
|
|
irmRules1.FreeMatchConversion( pMatch );
|
|
|
|
irmRules1.MatchRequestToBinary( "all", &pBin, &dwBin );
|
|
irmRules1.BinaryToMatchRequest( pBin, dwBin, &pMatch );
|
|
irmRules1.FreeMatchConversion( pBin );
|
|
irmRules1.FreeMatchConversion( pMatch );
|
|
|
|
irmRules1.MatchRequestToBinary( "*in*", &pBin, &dwBin );
|
|
irmRules1.BinaryToMatchRequest( pBin, dwBin, &pMatch );
|
|
irmRules1.FreeMatchConversion( pBin );
|
|
irmRules1.FreeMatchConversion( pMatch );
|
|
}
|
|
#endif
|
|
|
|
|
|
BOOL
|
|
AddFromFile(
|
|
CIisAcctMapper *pMap,
|
|
UnivMap *pU,
|
|
LPSTR pszFileName
|
|
)
|
|
{
|
|
FILE* f;
|
|
BinaryObject bo[16];
|
|
UINT cBo;
|
|
char buf[8192];
|
|
BOOL fSt = FALSE;
|
|
LPSTR p;
|
|
LPSTR pN;
|
|
LPSTR pH;
|
|
LPSTR pDH;
|
|
BOOL fLast;
|
|
|
|
if ( !(f = fopen( pszFileName, "r" )) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// build array of ptr to arg for Add
|
|
|
|
for ( ; fgets( buf, sizeof(buf), f ) ; )
|
|
{
|
|
if ( p = strchr(buf,'\n') )
|
|
{
|
|
*p = '\0';
|
|
}
|
|
|
|
p = buf;
|
|
|
|
if ( !_memicmp( p, "map ", sizeof("map ")-1 ) )
|
|
{
|
|
p += sizeof("map ")-1;
|
|
cBo = 0;
|
|
for ( ; *p ; )
|
|
{
|
|
if ( (pN = strchr( p, ' ' )) == NULL )
|
|
{
|
|
pN = p + strlen( p );
|
|
fLast = TRUE;
|
|
}
|
|
else
|
|
{
|
|
*pN = '\0';
|
|
fLast = FALSE;
|
|
}
|
|
|
|
if ( !_memicmp( p, "hex:", sizeof("hex:")-1 ) )
|
|
{
|
|
pH = p + sizeof("hex:")-1;
|
|
pDH = p;
|
|
while ( pH+1 < pN )
|
|
{
|
|
*pDH++ = (AscToHex(pH[0])<<4) | AscToHex(pH[1]) ;
|
|
pH += 2;
|
|
}
|
|
bo[cBo].pB = (LPBYTE)p;
|
|
bo[cBo].cB = pDH - p;
|
|
}
|
|
else
|
|
{
|
|
bo[cBo].pB = (LPBYTE)p;
|
|
bo[cBo].cB = pN - p;
|
|
}
|
|
++cBo;
|
|
|
|
if ( !fLast )
|
|
{
|
|
p = pN + 1;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( pU->AddBinary( bo, cBo ) )
|
|
{
|
|
fSt = TRUE;
|
|
printf( "Certificate added\n" );
|
|
}
|
|
else
|
|
{
|
|
printf( "Error adding certificate\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose( f );
|
|
|
|
return fSt;
|
|
}
|
|
|
|
|
|
void
|
|
Usage(
|
|
VOID
|
|
)
|
|
{
|
|
printf( "Usage:\n"
|
|
// "iisamap (md5|ita|cert|cert11)\n"
|
|
"iisamap cert11\n"
|
|
" [-a map_info] : add mapping\n"
|
|
" [-d map_info] : delete mapping\n"
|
|
" [-D#] : delete mapping\n"
|
|
// " [-e map_info] : check mapping exist\n"
|
|
// " [-m match_info] : display match\n"
|
|
" [-l] : list mappings\n"
|
|
" [-L#] : list mapping\n"
|
|
// " [-pfg : get subject field used as acct source (cert11 only)\n"
|
|
// " [-pfs field_name: set subject field used as acct source (cert11 only)\n"
|
|
// " [-pdg : get domain used in acct (cert11 only)\n"
|
|
// " [-pds domain: set domain used in acct (cert11 only)\n"
|
|
);
|
|
}
|
|
|
|
|
|
int __cdecl
|
|
main(
|
|
int argc,
|
|
char*argv[]
|
|
)
|
|
{
|
|
int arg;
|
|
int cnt;
|
|
CIisAcctMapper *pMap = NULL;
|
|
UnivMap *pU = NULL;
|
|
BOOL fUpdate = FALSE;
|
|
LPSTR pF;
|
|
int st = 0;
|
|
|
|
if ( argc < 2 )
|
|
{
|
|
Usage();
|
|
return 1;
|
|
}
|
|
|
|
for ( cnt = 0, arg = 1 ; arg < argc ; ++ arg )
|
|
{
|
|
if ( argv[arg][0] == '-' )
|
|
{
|
|
if ( pMap == NULL )
|
|
{
|
|
Usage();
|
|
return 1;
|
|
}
|
|
|
|
switch ( argv[arg][1] )
|
|
{
|
|
case 'a':
|
|
if ( !pU->Add( argv+arg+1 ) )
|
|
{
|
|
printf( "Error adding mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
fUpdate = TRUE;
|
|
break;
|
|
|
|
case 'A': // add from file
|
|
if ( !AddFromFile( pMap, pU, argv[arg]+2 ) )
|
|
{
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
fUpdate = TRUE;
|
|
break;
|
|
|
|
case 'm':
|
|
if ( !pU->Map( argv+arg+1 ) )
|
|
{
|
|
printf( "Error locating mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
pU->ListCurrent();
|
|
break;
|
|
|
|
case 'd':
|
|
if ( !pU->Locate( argv+arg+1 ) )
|
|
{
|
|
printf( "Error locating mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
if ( !pU->DeleteCurrent() )
|
|
{
|
|
printf( "Error deleting mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
fUpdate = TRUE;
|
|
break;
|
|
|
|
case 'D':
|
|
if ( !pU->SetCurrent( atoi((LPCTSTR)(argv[arg]+2))-1 ) )
|
|
{
|
|
printf( "Error accessing mapping %d\n", atoi((LPCTSTR)(argv+arg+1)) );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
if ( !pU->DeleteCurrent() )
|
|
{
|
|
printf( "Error deleting mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
fUpdate = TRUE;
|
|
break;
|
|
|
|
case 'e':
|
|
if ( !pU->Locate( argv+arg+1 ) )
|
|
{
|
|
printf( "Error locating mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
if ( !pU->ListCurrent() )
|
|
{
|
|
printf( "Error listing mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
break;
|
|
|
|
case 'l':
|
|
pU->List();
|
|
break;
|
|
|
|
case 'L':
|
|
if ( !pU->SetCurrent( atoi((LPCTSTR)(argv[arg]+2))-1 ) )
|
|
{
|
|
printf( "Error accessing mapping %d\n", atoi((LPCTSTR)(argv[arg]+2)) );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
if ( !pU->ListCurrent() )
|
|
{
|
|
printf( "Error listing mapping\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
break;
|
|
|
|
case 'p':
|
|
switch( DBL_CHAR_CMD( argv[arg][2], argv[arg][3]) )
|
|
{
|
|
case DBL_CHAR_CMD( 'f', 'g' ):
|
|
if ( !(pF = pU->SubjectFieldDisplay()) )
|
|
{
|
|
printf( "Error accessing subject field\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
printf( "Subject field : %s\b", pF );
|
|
break;
|
|
|
|
case DBL_CHAR_CMD( 'f', 's' ):
|
|
if ( !pU->SubjectFieldSet( argv[++arg] ) )
|
|
{
|
|
printf( "Error setting subject field\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
fUpdate = TRUE;
|
|
break;
|
|
|
|
case DBL_CHAR_CMD( 'd', 'g' ):
|
|
if ( !(pF = pU->DomainDisplay()) )
|
|
{
|
|
printf( "Error accessing domain\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
printf( "Domain : %s\b", pF );
|
|
break;
|
|
|
|
case DBL_CHAR_CMD( 'd', 's' ):
|
|
if ( !pU->DomainSet( argv[++arg] ) )
|
|
{
|
|
printf( "Error setting domain\n" );
|
|
st = 3;
|
|
goto ex;
|
|
}
|
|
fUpdate = TRUE;
|
|
break;
|
|
|
|
default:
|
|
Usage();
|
|
st = 1;
|
|
goto ex;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Usage();
|
|
st = 1;
|
|
goto ex;
|
|
}
|
|
if ( fUpdate )
|
|
{
|
|
if ( !pU->Save() )
|
|
{
|
|
printf( "Can't save mappings\n" );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
switch ( cnt )
|
|
{
|
|
case 0:
|
|
if ( !_stricmp( argv[arg], "md5" ) )
|
|
{
|
|
pMap = (CIisAcctMapper*)&mpMd5;
|
|
pU = (UnivMap*)&umMd5;
|
|
}
|
|
else if ( !_stricmp( argv[arg], "ita" ) )
|
|
{
|
|
pMap = (CIisAcctMapper*)&mpIta;
|
|
pU = (UnivMap*)&umIta;
|
|
}
|
|
else if ( !_stricmp( argv[arg], "cert" ) )
|
|
{
|
|
pMap = (CIisAcctMapper*)&mpCert;
|
|
pU = (UnivMap*)&umCert;
|
|
}
|
|
else if ( !_stricmp( argv[arg], "cert11" ) )
|
|
{
|
|
pMap = (CIisAcctMapper*)&mpCert11;
|
|
pU = (UnivMap*)&umCert11;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( !pU->Init( pMap ) )
|
|
{
|
|
printf( "Can't initialize mapper\n" );
|
|
pU = NULL;
|
|
return 2;
|
|
}
|
|
|
|
if ( !pU->Load() )
|
|
{
|
|
printf( "Failed to load mappings: mappings erased\n" );
|
|
}
|
|
++cnt;
|
|
}
|
|
}
|
|
|
|
ex:
|
|
if ( pU != NULL )
|
|
{
|
|
pU->Terminate();
|
|
}
|
|
|
|
return st;
|
|
}
|