Line data    Source code

       1             : // Copyright (C) 2009 The Android Open Source Project
       2             : //
       3             : // Licensed under the Apache License, Version 2.0 (the "License");
       4             : // you may not use this file except in compliance with the License.
       5             : // You may obtain a copy of the License at
       6             : //
       7             : // http://www.apache.org/licenses/LICENSE-2.0
       8             : //
       9             : // Unless required by applicable law or agreed to in writing, software
      10             : // distributed under the License is distributed on an "AS IS" BASIS,
      11             : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             : // See the License for the specific language governing permissions and
      13             : // limitations under the License.
      14             : 
      15             : package com.google.gerrit.auth.ldap;
      16             : 
      17             : import javax.naming.NamingException;
      18             : import javax.naming.directory.Attribute;
      19             : import javax.naming.directory.Attributes;
      20             : import javax.naming.directory.DirContext;
      21             : 
      22           0 : abstract class LdapType {
      23           0 :   static final LdapType RFC_2307 = new Rfc2307();
      24             : 
      25             :   static LdapType guessType(DirContext ctx) throws NamingException {
      26           0 :     final Attributes rootAtts = ctx.getAttributes("");
      27           0 :     Attribute supported = rootAtts.get("supportedCapabilities");
      28           0 :     if (supported != null
      29           0 :         && (supported.contains("1.2.840.113556.1.4.800")
      30           0 :             || supported.contains("1.2.840.113556.1.4.1851"))) {
      31           0 :       return new ActiveDirectory();
      32             :     }
      33             : 
      34           0 :     supported = rootAtts.get("supportedExtension");
      35           0 :     if (supported != null && supported.contains("2.16.840.1.113730.3.8.10.1")) {
      36           0 :       return new FreeIPA();
      37             :     }
      38             : 
      39           0 :     return RFC_2307;
      40             :   }
      41             : 
      42             :   abstract String groupPattern();
      43             : 
      44             :   abstract String groupMemberPattern();
      45             : 
      46             :   abstract String groupName();
      47             : 
      48             :   abstract String accountFullName();
      49             : 
      50             :   abstract String accountEmailAddress();
      51             : 
      52             :   abstract String accountSshUserName();
      53             : 
      54             :   abstract String accountMemberField();
      55             : 
      56             :   abstract boolean accountMemberExpandGroups();
      57             : 
      58             :   abstract String accountPattern();
      59             : 
      60             :   private static class Rfc2307 extends LdapType {
      61             :     @Override
      62             :     String groupPattern() {
      63           0 :       return "(cn=${groupname})";
      64             :     }
      65             : 
      66             :     @Override
      67             :     String groupMemberPattern() {
      68           0 :       return "(|(memberUid=${username})(gidNumber=${gidNumber}))";
      69             :     }
      70             : 
      71             :     @Override
      72             :     String groupName() {
      73           0 :       return "cn";
      74             :     }
      75             : 
      76             :     @Override
      77             :     String accountFullName() {
      78           0 :       return "displayName";
      79             :     }
      80             : 
      81             :     @Override
      82             :     String accountEmailAddress() {
      83           0 :       return "mail";
      84             :     }
      85             : 
      86             :     @Override
      87             :     String accountSshUserName() {
      88           0 :       return "uid";
      89             :     }
      90             : 
      91             :     @Override
      92             :     String accountMemberField() {
      93           0 :       return null; // Not defined in RFC 2307
      94             :     }
      95             : 
      96             :     @Override
      97             :     String accountPattern() {
      98           0 :       return "(uid=${username})";
      99             :     }
     100             : 
     101             :     @Override
     102             :     boolean accountMemberExpandGroups() {
     103           0 :       return true;
     104             :     }
     105             :   }
     106             : 
     107             :   private static class ActiveDirectory extends LdapType {
     108             :     @Override
     109             :     String groupPattern() {
     110           0 :       return "(&(objectClass=group)(cn=${groupname}))";
     111             :     }
     112             : 
     113             :     @Override
     114             :     String groupName() {
     115           0 :       return "cn";
     116             :     }
     117             : 
     118             :     @Override
     119             :     String groupMemberPattern() {
     120           0 :       return null; // Active Directory uses memberOf in the account
     121             :     }
     122             : 
     123             :     @Override
     124             :     String accountFullName() {
     125           0 :       return "${givenName} ${sn}";
     126             :     }
     127             : 
     128             :     @Override
     129             :     String accountEmailAddress() {
     130           0 :       return "mail";
     131             :     }
     132             : 
     133             :     @Override
     134             :     String accountSshUserName() {
     135           0 :       return "${sAMAccountName.toLowerCase}";
     136             :     }
     137             : 
     138             :     @Override
     139             :     String accountMemberField() {
     140           0 :       return "memberOf";
     141             :     }
     142             : 
     143             :     @Override
     144             :     String accountPattern() {
     145           0 :       return "(&(objectClass=user)(sAMAccountName=${username}))";
     146             :     }
     147             : 
     148             :     @Override
     149             :     boolean accountMemberExpandGroups() {
     150           0 :       return true;
     151             :     }
     152             :   }
     153             : 
     154             :   private static class FreeIPA extends LdapType {
     155             : 
     156             :     @Override
     157             :     String groupPattern() {
     158           0 :       return "(cn=${groupname})";
     159             :     }
     160             : 
     161             :     @Override
     162             :     String groupName() {
     163           0 :       return "cn";
     164             :     }
     165             : 
     166             :     @Override
     167             :     String groupMemberPattern() {
     168           0 :       return null; // FreeIPA uses memberOf in the account
     169             :     }
     170             : 
     171             :     @Override
     172             :     String accountFullName() {
     173           0 :       return "displayName";
     174             :     }
     175             : 
     176             :     @Override
     177             :     String accountEmailAddress() {
     178           0 :       return "mail";
     179             :     }
     180             : 
     181             :     @Override
     182             :     String accountSshUserName() {
     183           0 :       return "uid";
     184             :     }
     185             : 
     186             :     @Override
     187             :     String accountMemberField() {
     188           0 :       return "memberOf";
     189             :     }
     190             : 
     191             :     @Override
     192             :     String accountPattern() {
     193           0 :       return "(uid=${username})";
     194             :     }
     195             : 
     196             :     @Override
     197             :     boolean accountMemberExpandGroups() {
     198           0 :       return false;
     199             :     }
     200             :   }
     201             : }