]> andersk Git - moira.git/blame - incremental/ldap/winad.c
andersk / moira.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Skip group populate in some cases to speed up list processing.
[moira.git] / incremental / ldap / winad.c
CommitLineData
61a2844b 1/* $Header$
2/* ldap.incr arguments example
3 *
4 * arguments when moira creates the account - ignored by ldap.incr since the
5 * account is unusable. users 0 11 #45198 45198 /bin/cmd cmd Last First Middle
6 * 0 950000001 2000 121049
7 *
8 * login, unix_uid, shell, winconsoleshell, last,
9 * first, middle, status, mitid, type, moiraid
10 *
11 * arguments for creating or updating a user account
12 * users 11 11 username 45206 /bin/cmd cmd Last First Middle 2 950000001 STAFF
13 * 121058 PathToHomeDir PathToProfileDir username 45206 /bin/cmd cmd Last
14 * First Middle 1 950000001 STAFF 121058 PathToHomeDir PathToProfileDir
15 * users 11 11 #45206 45206 /bin/cmd cmd Last First Middle 0 950000001 STAFF
16 * 121058 PathToHomeDir PathToProfileDir newuser 45206 /bin/cmd cmd Last
17 * First Middle 2 950000001 STAFF 121058 PathToHomeDir PathToProfileDir
18 *
19 * login, unix_uid, shell, winconsoleshell, last, first, middle, status,
20 * mitid, type, moiraid
21 *
22 * arguments for deactivating/deleting a user account
23 * users 11 11 username 45206 /bin/cmd cmd Last First Middle 1 950000001 STAFF
24 * 121058 PathToHomeDir PathToProfileDir username 45206 /bin/cmd cmd Last
25 * First Middle 3 950000001 STAFF 121058 PathToHomeDir PathToProfileDir
26 * users 11 11 username 45206 /bin/cmd cmd Last First Middle 2 950000001 STAFF
27 * 121058 PathToHomeDir PathToProfileDir username 45206 /bin/cmd cmd Last
28 * First Middle 3 950000001 STAFF 121058 PathToHomeDir PathToProfileDir
29 *
30 * login, unix_uid, shell, winconsoleshell, last, first, middle, status,
31 * mitid, type, moiraid
32 *
33 * arguments for reactivating a user account
34 * users 11 11 username 45206 /bin/cmd cmd Last First Middle 3 950000001 STAFF
35 * 121058 username 45206 /bin/cmd cmd Last First Middle 1 950000001 STAFF
36 * 121058
37 * users 11 11 username 45206 /bin/cmd cmd Last First Middle 3 950000001 STAFF
38 * 121058 username 45206 /bin/cmd cmd Last First Middle 2 950000001 STAFF 12105
39 *
40 * login, unix_uid, shell, winconsoleshell, last, first, middle, status,
41 * mitid, type, moiraid
42 *
43 * arguments for changing user name
44 * users 11 11 oldusername 45206 /bin/cmd cmd Last First Middle 1 950000001
45 * STAFF 121058 PathToHomeDir PathToProfileDir newusername 45206 /bin/cmd cmd
46 * Last First Middle 1 950000001 STAFF 121058 PathToHomeDir PathToProfileDir
47 *
48 * login, unix_uid, shell, winconsoleshell, last, first, middle, status,
49 * mitid, type, moiraid
50 *
51 * arguments for expunging a user
52 * users 11 0 username 45198 /bin/cmd cmd Last First Middle 0 950000001 2000
53 * 121049
54 *
55 * login, unix_uid, shell, winconsoleshell, last, first, middle, status,
56 * mitid, type, moiraid
57 *
58 * arguments for creating a "special" group/list
59 * list 0 11 listname 1 1 0 0 0 -1 NONE 0 description 92616
60 *
61 * listname, active, publicflg, hidden, maillist, grouplist, gid, acl_type,
62 * acl_id, description, moiraid
63 *
64 * arguments for creating a "mail" group/list
65 * list 0 11 listname 1 1 0 1 0 -1 NONE 0 description 92616
66 *
67 * listname, active, publicflg, hidden, maillist, grouplist, gid, acl_type,
68 * acl_id, description, moiraid
69 *
70 * arguments for creating a "group" group/list
71 * list 0 11 listname 1 1 0 0 1 -1 NONE 0 description 92616
72 *
73 * listname, active, publicflg, hidden, maillist, grouplist, gid, acl_type,
74 * acl_id, description, moiraid
75 *
76 * arguments for creating a "group/mail" group/list
77 * list 0 11 listname 1 1 0 1 1 -1 NONE 0 description 92616
78 *
79 * listname, active, publicflg, hidden, maillist, grouplist, gid, acl_type,
80 * acl_id, description, moiraid
81 *
82 * arguments to add a USER member to group/list
83 * imembers 0 12 listname USER userName 1 1 0 0 0 -1 1 92616 121047
84 *
85 * list_name, user_type, name, active, publicflg, hidden, maillist, grouplist,
86 * gid, userStatus, moiraListId, moiraUserId
87 *
88 * arguments to add a STRING or KERBEROS member to group/list
89 * imembers 0 10 listname STRING stringName 1 1 0 0 0 -1 92616
90 * imembers 0 10 listlistnameName KERBEROS kerberosName 1 1 0 0 0 -1 92616
91 *
92 * list_name, user_type, name, active, publicflg, hidden, maillist, grouplist,
93 * gid, moiraListId
94 *
95 * NOTE: group members of type LIST are ignored.
96 *
97 * arguments to remove a USER member to group/list
98 * imembers 12 0 listname USER userName 1 1 0 0 0 -1 1 92616 121047
99 *
100 * list_name, user_type, name, active, publicflg, hidden, maillist, grouplist,
101 * gid, userStatus, moiraListId, moiraUserId
102 *
103 * arguments to remove a STRING or KERBEROS member to group/list
104 * imembers 10 0 listname STRING stringName 1 1 0 0 0 -1 92616
105 * imembers 10 0 listname KERBEROS kerberosName 1 1 0 0 0 -1 92616
106 *
107 * list_name, user_type, name, active, publicflg, hidden, maillist, grouplist,
108 * gid, moiraListId
109 *
110 * NOTE: group members of type LIST are ignored.
111 *
112 * arguments for renaming a group/list
113 * list 11 11 oldlistname 1 1 0 0 0 -1 NONE 0 description 92616 newlistname 1
114 * 1 0 0 0 -1 description 0 92616
115 *
116 * name, active, publicflg, hidden, maillist, grouplist, gid, acl_type,
117 * acl_id, description, moiraListId
118 *
119 * arguments for deleting a group/list
120 * list 11 0 listname 1 1 0 0 0 -1 NONE 0 description 92616
121 *
122 * name, active, publicflg, hidden, maillist, grouplist, gid, acl_type,
123 * acl_id, description, moiraListId
124 *
125 * arguments for adding a file system
126 * filesys 0 12 username AFS ATHENA.MIT.EDU
127 * /afs/athena.mit.edu/user/n/e/username /mit/username w descripton username
128 * wheel 1 HOMEDIR 101727
129 *
130 * arguments for deleting a file system
131 * filesys 12 0 username AFS ATHENA.MIT.EDU
132 * /afs/athena.mit.edu/user/n/e/username /mit/username w descripton username
133 * wheel 1 HOMEDIR 101727
134 *
135 * arguments when moira creates a container (OU).
136 * containers 0 8 machines/test/bottom description location contact USER
137 * 105316 2222 [none]
138 *
139 * arguments when moira deletes a container (OU).
140 * containers 8 0 machines/test/bottom description location contact USER
141 * 105316 2222 groupname
142 *
143 * arguments when moira modifies a container information (OU).
144 * containers 8 8 machines/test/bottom description location contact USER
145 * 105316 2222 groupname machines/test/bottom description1 location contact
146 * USER 105316 2222 groupname
147 *
148 * arguments when moira adds a machine from an OU
149 * table name, beforec, afterc, machine_name, container_name, mach_id, cnt_id
150 * mcntmap 0 5 DAVIDT.MIT.EDU dttest/dttest1 76767 46 groupname
151 *
152 * arguments when moira removes a machine from an OU
153 * table name, beforec, afterc, machine_name, container_name, mach_id, cnt_id
154 * mcntmap 0 5 DAVIDT.MIT.EDU dttest/dttest1 76767 46 groupname
155 *
156*/
157
158#include <mit-copyright.h>
159
160#ifdef _WIN32
161#include <winsock2.h>
162#include <windows.h>
163#include <stdlib.h>
164#include <malloc.h>
165#include <lmaccess.h>
166#endif
167
168#include <hesiod.h>
169#include <string.h>
170#include <ldap.h>
171#include <stdio.h>
172#include <moira.h>
173#include <moira_site.h>
174#include <mrclient.h>
175#include <krb5.h>
176#include <gsssasl.h>
177#include <gssldap.h>
178#include "kpasswd.h"
179
180#ifdef _WIN32
181#ifndef ECONNABORTED
182#define ECONNABORTED WSAECONNABORTED
183#endif
184#ifndef ECONNREFUSED
185#define ECONNREFUSED WSAECONNREFUSED
186#endif
187#ifndef EHOSTUNREACH
188#define EHOSTUNREACH WSAEHOSTUNREACH
189#endif
190#define krb5_xfree free
191#define F_OK 0
192#define sleep(A) Sleep(A * 1000);
193#endif /* _WIN32 */
194
195#ifndef _WIN32
196#include <sys/types.h>
197#include <netinet/in.h>
198#include <arpa/nameser.h>
199#include <resolv.h>
200#include <sys/utsname.h>
201#include <unistd.h>
202
203#define CFG_PATH "/moira/ldap/"
204#define WINADCFG "ldap.cfg"
205#define strnicmp(A,B,C) strncasecmp(A,B,C)
206#define UCHAR unsigned char
207
208#define UF_SCRIPT 0x0001
209#define UF_ACCOUNTDISABLE 0x0002
210#define UF_HOMEDIR_REQUIRED 0x0008
211#define UF_LOCKOUT 0x0010
212#define UF_PASSWD_NOTREQD 0x0020
213#define UF_PASSWD_CANT_CHANGE 0x0040
214#define UF_DONT_EXPIRE_PASSWD 0x10000
215
216#define UF_TEMP_DUPLICATE_ACCOUNT 0x0100
217#define UF_NORMAL_ACCOUNT 0x0200
218#define UF_INTERDOMAIN_TRUST_ACCOUNT 0x0800
219#define UF_WORKSTATION_TRUST_ACCOUNT 0x1000
220#define UF_SERVER_TRUST_ACCOUNT 0x2000
221
222#define OWNER_SECURITY_INFORMATION (0x00000001L)
223#define GROUP_SECURITY_INFORMATION (0x00000002L)
224#define DACL_SECURITY_INFORMATION (0x00000004L)
225#define SACL_SECURITY_INFORMATION (0x00000008L)
226
227#ifndef BYTE
228#define BYTE unsigned char
229#endif
230typedef unsigned int DWORD;
231typedef unsigned long ULONG;
232
233typedef struct _GUID
234{
235 unsigned long Data1;
236 unsigned short Data2;
237 unsigned short Data3;
238 unsigned char Data4[8];
239} GUID;
240
241typedef struct _SID_IDENTIFIER_AUTHORITY {
242 BYTE Value[6];
243} SID_IDENTIFIER_AUTHORITY, *PSID_IDENTIFIER_AUTHORITY;
244
245typedef struct _SID {
246 BYTE Revision;
247 BYTE SubAuthorityCount;
248 SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
249 DWORD SubAuthority[512];
250} SID;
251#endif/*!WIN32*/
252
253#ifndef WINADCFG
254#define WINADCFG "ldap.cfg"
255#endif
256
257#ifndef CFG_PATH
258#define CFG_PATH ""
259#endif
260
261#define AFS "/afs/"
262#define WINAFS "\\\\afs\\all\\"
263
264#define ADS_GROUP_TYPE_GLOBAL_GROUP 0x00000002
265#define ADS_GROUP_TYPE_DOMAIN_LOCAL_GROUP 0x00000004
266#define ADS_GROUP_TYPE_LOCAL_GROUP 0x00000004
267#define ADS_GROUP_TYPE_UNIVERSAL_GROUP 0x00000008
268#define ADS_GROUP_TYPE_SECURITY_ENABLED 0x80000000
269
270#define QUERY_VERSION -1
271#define PRIMARY_REALM "ATHENA.MIT.EDU"
272#define PRIMARY_DOMAIN "win.mit.edu"
273#define PRODUCTION_PRINCIPAL "sms"
274#define TEST_PRINCIPAL "smstest"
275
276#define SUBSTITUTE 1
277#define REPLACE 2
278
279#define USERS 0
280#define GROUPS 1
281
282#define MEMBER_ADD 1
283#define MEMBER_REMOVE 2
284#define MEMBER_CHANGE_NAME 3
285#define MEMBER_ACTIVATE 4
286#define MEMBER_DEACTIVATE 5
287#define MEMBER_CREATE 6
288
289#define MOIRA_ALL 0x0
290#define MOIRA_USERS 0x1
291#define MOIRA_KERBEROS 0x2
292#define MOIRA_STRINGS 0x4
293#define MOIRA_LISTS 0x8
e8332ac3 294#define MOIRA_MACHINE 0x16
61a2844b 295
296#define CHECK_GROUPS 1
297#define CLEANUP_GROUPS 2
298
299#define AD_NO_GROUPS_FOUND -1
300#define AD_WRONG_GROUP_DN_FOUND -2
301#define AD_MULTIPLE_GROUPS_FOUND -3
302#define AD_INVALID_NAME -4
303#define AD_LDAP_FAILURE -5
304#define AD_INVALID_FILESYS -6
305#define AD_NO_ATTRIBUTE_FOUND -7
306#define AD_NO_OU_FOUND -8
307#define AD_NO_USER_FOUND -9
308
309/* container arguments */
310#define CONTAINER_NAME 0
311#define CONTAINER_DESC 1
312#define CONTAINER_LOCATION 2
313#define CONTAINER_CONTACT 3
314#define CONTAINER_TYPE 4
315#define CONTAINER_ID 5
316#define CONTAINER_ROWID 6
317#define CONTAINER_GROUP_NAME 7
318
319/*mcntmap arguments*/
320#define OU_MACHINE_NAME 0
321#define OU_CONTAINER_NAME 1
322#define OU_MACHINE_ID 2
323#define OU_CONTAINER_ID 3
324#define OU_CONTAINER_GROUP 4
325
326typedef struct lk_entry {
327 int op;
328 int length;
329 int ber_value;
330 char *dn;
331 char *attribute;
332 char *value;
333 char *member;
334 char *type;
335 char *list;
336 struct lk_entry *next;
337} LK_ENTRY;
338
339#define STOP_FILE "/moira/ldap/noldap"
340#define file_exists(file) (access((file), F_OK) == 0)
341
342#define N_SD_BER_BYTES 5
343#define LDAP_BERVAL struct berval
344#define MAX_SERVER_NAMES 32
345
346#define HIDDEN_GROUP "HiddenGroup.g"
347#define HIDDEN_GROUP_WITH_ADMIN "HiddenGroupWithAdmin.g"
348#define NOT_HIDDEN_GROUP "NotHiddenGroup.g"
349#define NOT_HIDDEN_GROUP_WITH_ADMIN "NotHiddenGroupWithAdmin.g"
350
351#define ADDRESS_LIST_PREFIX "CN=MIT Directory,CN=All Address Lists,\
352CN=Address Lists Container,CN=Massachusetts Institute of Technology,\
353CN=Microsoft Exchange,CN=Services,CN=Configuration,"
354
c95d6ec1 355#define GLOBAL_ADDRESS_LIST_PREFIX "CN=Default Global Address List,\
356CN=All Global Address Lists,CN=Address Lists Container,\
357CN=Massachusetts Institute of Technology,CN=Microsoft Exchange,CN=Services,\
358CN=Configuration,"
359
360#define EMAIL_ADDRESS_LIST_PREFIX "CN=Email Users,CN=All Users,\
361CN=All Address Lists,CN=Address Lists Container,\
362CN=Massachusetts Institute of Technology,CN=Microsoft Exchange,\
363CN=Services,CN=Configuration,"
364
365#define ALL_ADDRESS_LIST_PREFIX "CN=All Users,CN=All Address Lists,\
366CN=Address Lists Container,CN=Massachusetts Institute of Technology,\
367CN=Microsoft Exchange,CN=Services,CN=Configuration,"
368
7be1cfa9 369#define X500_PREFIX "X500:/o=Massachusetts Institute of Technology/\
370ou=Exchange Administrative Group (FYDIBOHF23SPDLT)/cn=Recipients"
371
61a2844b 372#define ADD_ATTR(t, v, o) \
373 mods[n] = malloc(sizeof(LDAPMod)); \
374 mods[n]->mod_op = o; \
375 mods[n]->mod_type = t; \
376 mods[n++]->mod_values = v
377
378#define DEL_ATTR(t, o) \
379 DelMods[i] = malloc(sizeof(LDAPMod)); \
380 DelMods[i]->mod_op = o; \
381 DelMods[i]->mod_type = t; \
382 DelMods[i++]->mod_values = NULL
383
384#define DOMAIN_SUFFIX "MIT.EDU"
385#define DOMAIN "DOMAIN:"
386#define PRINCIPALNAME "PRINCIPAL:"
387#define SERVER "SERVER:"
388#define MSSFU "SFU:"
389#define SFUTYPE "30"
390#define GROUP_SUFFIX "GROUP_SUFFIX:"
391#define GROUP_TYPE "GROUP_TYPE:"
392#define SET_GROUP_ACE "SET_GROUP_ACE:"
393#define SET_PASSWORD "SET_PASSWORD:"
394#define EXCHANGE "EXCHANGE:"
395#define REALM "REALM:"
396#define ACTIVE_DIRECTORY "ACTIVE_DIRECTORY:"
397#define PORT "PORT:"
398#define PROCESS_MACHINE_CONTAINER "PROCESS_MACHINE_CONTAINER:"
e8332ac3 399#define GROUP_POPULATE_MEMBERS "GROUP_POPULATE_MEMBERS:"
8b76dea3 400#define MAX_MEMBERS "MAX_MEMBERS:"
61a2844b 401#define MAX_DOMAINS 10
402char DomainNames[MAX_DOMAINS][128];
403
404LK_ENTRY *member_base = NULL;
405
406char PrincipalName[128];
407static char tbl_buf[1024];
408char kerberos_ou[] = "OU=kerberos,OU=moira";
409char contact_ou[] = "OU=strings,OU=moira";
410char user_ou[] = "OU=users,OU=moira";
411char group_ou_distribution[1024];
412char group_ou_root[1024];
413char group_ou_security[1024];
414char group_ou_neither[1024];
415char group_ou_both[1024];
416char orphans_machines_ou[] = "OU=Machines,OU=Orphans";
417char orphans_other_ou[] = "OU=Other,OU=Orphans";
418char security_template_ou[] = "OU=security_templates";
419char *whoami;
420char ldap_domain[256];
421char ldap_realm[256];
422char ldap_port[256];
423char *ServerList[MAX_SERVER_NAMES];
424char default_server[256];
425static char tbl_buf[1024];
426char group_suffix[256];
427char exchange_acl[256];
428int mr_connections = 0;
429int callback_rc;
430int UseSFU30 = 0;
431int UseGroupSuffix = 1;
432int UseGroupUniversal = 0;
433int SetGroupAce = 1;
434int SetPassword = 1;
435int Exchange = 0;
436int ProcessMachineContainer = 1;
437int ActiveDirectory = 1;
438int UpdateDomainList;
5f6343e6 439int fsgCount;
e8332ac3 440int GroupPopulateDelete = 0;
8b76dea3 441int group_members = 0;
442int max_group_members = 0;
61a2844b 443
444extern int set_password(char *user, char *password, char *domain);
445
446int ad_get_group(LDAP *ldap_handle, char *dn_path, char *group_name,
447 char *group_membership, char *MoiraId, char *attribute,
448 LK_ENTRY **linklist_base, int *linklist_count,
449 char *rFilter);
450void AfsToWinAfs(char* path, char* winPath);
451int ad_connect(LDAP **ldap_handle, char *ldap_domain, char *dn_path,
452 char *Win2kPassword, char *Win2kUser, char *default_server,
453 int connect_to_kdc, char **ServerList, char *ldap_realm,
454 char *ldap_port);
455void ad_kdc_disconnect();
456int ad_server_connect(char *connectedServer, char *domain);
457int attribute_update(LDAP *ldap_handle, char *distinguished_name,
458 char *attribute_value, char *attribute, char *user_name);
459int BEREncodeSecurityBits(ULONG uBits, char *pBuffer);
460int checkADname(LDAP *ldap_handle, char *dn_path, char *Name);
461int check_winad(void);
462int check_user(LDAP *ldap_handle, char *dn_path, char *UserName,
463 char *MoiraId);
464/* containers */
465int container_adupdate(LDAP *ldap_handle, char *dn_path, char *dName,
466 char *distinguishedName, int count, char **av);
467void container_check(LDAP *ldap_handle, char *dn_path, char *name);
468int container_create(LDAP *ldap_handle, char *dn_path, int count, char **av);
469int container_delete(LDAP *ldap_handle, char *dn_path, int count, char **av);
470int container_get_distinguishedName(LDAP *ldap_handle, char *dn_path,
471 char *distinguishedName, int count,
472 char **av);
473void container_get_dn(char *src, char *dest);
474void container_get_name(char *src, char *dest);
475int container_move_objects(LDAP *ldap_handle, char *dn_path, char *dName);
476int container_rename(LDAP *ldap_handle, char *dn_path, int beforec,
477 char **before, int afterc, char **after);
478int container_update(LDAP *ldap_handle, char *dn_path, int beforec,
479 char **before, int afterc, char **after);
480
481int GetAceInfo(int ac, char **av, void *ptr);
482int get_group_membership(char *group_membership, char *group_ou,
483 int *security_flag, char **av);
484int get_machine_ou(LDAP *ldap_handle, char *dn_path, char *member,
485 char *machine_ou, char *pPtr);
486int Moira_container_group_create(char **after);
487int Moira_container_group_delete(char **before);
488int Moira_groupname_create(char *GroupName, char *ContainerName,
489 char *ContainerRowID);
490int Moira_container_group_update(char **before, char **after);
491int Moira_process_machine_container_group(char *MachineName, char* groupName,
492 int DeleteMachine);
493int Moira_addGroupToParent(char *origContainerName, char *GroupName);
494int Moira_getContainerGroup(int ac, char **av, void *ptr);
495int Moira_getGroupName(char *origContainerName, char *GroupName,
496 int ParentFlag);
497int Moira_setContainerGroup(char *ContainerName, char *GroupName);
498int ProcessAce(LDAP *ldap_handle, char *dn_path, char *group_name, char *Type,
c95d6ec1 499 int UpdateGroup, int *ProcessGroup, char *maillist,
500 char *nfsgroup);
61a2844b 501int process_group(LDAP *ldap_handle, char *dn_path, char *MoiraId,
502 char *group_name, char *group_ou, char *group_membership,
c95d6ec1 503 int group_security_flag, int type, char *maillist,
504 char *nfsgroup);
61a2844b 505int process_lists(int ac, char **av, void *ptr);
506int ProcessGroupSecurity(LDAP *ldap_handle, char *dn_path,
507 char *TargetGroupName, int HiddenGroup,
508 char *AceType, char *AceName);
509int ProcessMachineName(int ac, char **av, void *ptr);
510int ReadConfigFile(char *DomainName);
511int ReadDomainList();
512void StringTrim(char *StringToTrim);
513char *escape_string(char *s);
514int save_query_info(int argc, char **argv, void *hint);
5f6343e6 515int save_fsgroup_info(int argc, char **argv, void *hint);
61a2844b 516int user_create(int ac, char **av, void *ptr);
517int user_change_status(LDAP *ldap_handle, char *dn_path,
518 char *user_name, char *MoiraId, int operation);
519int user_delete(LDAP *ldap_handle, char *dn_path,
520 char *u_name, char *MoiraId);
521int user_rename(LDAP *ldap_handle, char *dn_path, char *before_user_name,
522 char *user_name);
523int user_update(LDAP *ldap_handle, char *dn_path, char *user_name,
524 char *uid, char *MitId, char *MoiraId, int State,
525 char *WinHomeDir, char *WinProfileDir, char *first,
526 char *middle, char *last, char *shell, char *class);
527void change_to_lower_case(char *ptr);
528int contact_create(LDAP *ld, char *bind_path, char *user, char *group_ou);
529int contact_remove_email(LDAP *ld, char *bind_path,
530 LK_ENTRY **linklist_entry, int linklist_current);
531int group_create(int ac, char **av, void *ptr);
532int group_delete(LDAP *ldap_handle, char *dn_path,
533 char *group_name, char *group_membership, char *MoiraId);
534int group_rename(LDAP *ldap_handle, char *dn_path,
535 char *before_group_name, char *before_group_membership,
536 char *before_group_ou, int before_security_flag,
537 char *before_desc, char *after_group_name,
538 char *after_group_membership, char *after_group_ou,
539 int after_security_flag, char *after_desc,
c95d6ec1 540 char *MoiraId, char *filter, char *maillist, char *nfsgroup);
61a2844b 541int machine_check(LDAP *ldap_handle, char *dn_path, char *machine_name);
542int machine_GetMoiraContainer(int ac, char **av, void *ptr);
543int machine_get_moira_container(LDAP *ldap_handle, char *dn_path,
544 char *machine_name, char *container_name);
545int machine_move_to_ou(LDAP *ldap_handle, char *dn_path,
546 char *MoiraMachineName, char *DestinationOu);
547int make_new_group(LDAP *ldap_handle, char *dn_path, char *MoiraId,
548 char *group_name, char *group_ou, char *group_membership,
c95d6ec1 549 int group_security_flag, int updateGroup, char *maillist,
550 char *nfsgroup);
61a2844b 551int member_list_build(int ac, char **av, void *ptr);
552int member_add(LDAP *ldap_handle, char *dn_path, char *group_name,
553 char *group_ou, char *group_membership,
554 char *user_name, char *pUserOu, char *MoiraId);
555int member_remove(LDAP *ldap_handle, char *dn_path, char *group_name,
556 char *group_ou, char *group_membership, char *user_name,
557 char *pUserOu, char *MoiraId);
d6232129 558int contains_member(LDAP *ldap_handle, char *dn_path, char *group_name,
559 char *UserOu, char *member);
61a2844b 560int populate_group(LDAP *ldap_handle, char *dn_path, char *group_name,
561 char *group_ou, char *group_membership,
8b76dea3 562 int group_security_flag, char *MoiraId, int synchronize);
61a2844b 563int SetHomeDirectory(LDAP *ldap_handle, char *user_name,
564 char *DistinguishedName,
565 char *WinHomeDir, char *WinProfileDir,
566 char **homedir_v, char **winProfile_v,
567 char **drives_v, LDAPMod **mods,
568 int OpType, int n);
569int sid_update(LDAP *ldap_handle, char *dn_path);
570void SwitchSFU(LDAPMod **mods, int *UseSFU30, int n);
571int check_string(char *s);
572int check_container_name(char* s);
573
574int mr_connect_cl(char *server, char *client, int version, int auth);
575void do_container(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
576 char **before, int beforec, char **after, int afterc);
577void do_filesys(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
578 char **before, int beforec, char **after, int afterc);
579void do_list(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
580 char **before, int beforec, char **after, int afterc);
581void do_user(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
582 char **before, int beforec, char **after, int afterc);
583void do_member(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
584 char **before, int beforec, char **after, int afterc);
585void do_mcntmap(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
586 char **before, int beforec, char **after, int afterc);
587int linklist_create_entry(char *attribute, char *value,
588 LK_ENTRY **linklist_entry);
589int linklist_build(LDAP *ldap_handle, char *dn_path, char *search_exp,
590 char **attr_array, LK_ENTRY **linklist_base,
591 int *linklist_count, unsigned long ScopeType);
592void linklist_free(LK_ENTRY *linklist_base);
593
594int retrieve_attributes(LDAP *ldap_handle, LDAPMessage *ldap_entry,
595 char *distinguished_name, LK_ENTRY **linklist_current);
596int retrieve_entries(LDAP *ldap_handle, LDAPMessage *ldap_entry,
597 LK_ENTRY **linklist_base, int *linklist_count);
598int retrieve_values(LDAP *ldap_handle, LDAPMessage *ldap_entry,
599 char *Attribute, char *distinguished_name,
600 LK_ENTRY **linklist_current);
601
602int construct_newvalues(LK_ENTRY *linklist_base, int modvalue_count,
603 char *oldValue, char *newValue,
604 char ***modvalues, int type);
605void free_values(char **modvalues);
606
607int convert_domain_to_dn(char *domain, char **bind_path);
608void get_distinguished_name(LDAP *ldap_handle, LDAPMessage *ldap_entry,
609 char *distinguished_name);
610int moira_disconnect(void);
611int moira_connect(void);
612void print_to_screen(const char *fmt, ...);
613int GetMachineName(char *MachineName);
614int tickets_get_k5();
615int destroy_cache(void);
616int dest_tkt(void);
617
618int find_homeMDB(LDAP *ldap_handle, char *dn_path, char **homeMDB,
619 char **homeServerName);
620
621int main(int argc, char **argv)
622{
623 unsigned long rc;
624 int beforec;
625 int afterc;
626 int i;
627 int j;
628 int k;
629 int OldUseSFU30;
630 char *table;
631 char **before;
632 char **after;
633 LDAP *ldap_handle;
634 char dn_path[256];
635 char *orig_argv[64];
636
637 whoami = ((whoami = (char *)strrchr(argv[0], '/')) ? whoami+1 : argv[0]);
638
639 if (argc < 4)
640 {
641 com_err(whoami, 0, "Unable to process %s", "argc < 4");
642 exit(1);
643 }
644
645 if (argc < (4 + atoi(argv[2]) + atoi(argv[3])))
646 {
647 com_err(whoami, 0, "Unable to process %s",
648 "argc < (4 + beforec + afterc)");
649 exit(1);
650 }
651
652 if (!strcmp(argv[1], "filesys"))
653 exit(0);
654
655 for (i = 1; i < argc; i++)
656 {
657 strcat(tbl_buf, argv[i]);
658 strcat(tbl_buf, " ");
659 }
660
661 com_err(whoami, 0, "%s", tbl_buf);
662
663 if (check_winad())
664 {
665 com_err(whoami, 0, "%s failed", "check_winad()");
666 exit(1);
667 }
668
669 initialize_sms_error_table();
670 initialize_krb_error_table();
671
672 UpdateDomainList = 0;
673 memset(DomainNames, '\0', sizeof(DomainNames[0]) * MAX_DOMAINS);
674
675 if (ReadDomainList())
676 {
677 com_err(whoami, 0, "%s failed", "ReadDomainList()");
678 exit(1);
679 }
680
681 for (i = 0; i < argc; i++)
682 orig_argv[i] = NULL;
683
684 for (k = 0; k < MAX_DOMAINS; k++)
685 {
686 if (strlen(DomainNames[k]) == 0)
687 continue;
688 for (i = 0; i < argc; i++)
689 {
690 if (orig_argv[i] != NULL)
691 free(orig_argv[i]);
692 orig_argv[i] = strdup(argv[i]);
693 }
694
695 memset(PrincipalName, '\0', sizeof(PrincipalName));
696 memset(ldap_domain, '\0', sizeof(ldap_domain));
697 memset(ServerList, '\0', sizeof(ServerList[0]) * MAX_SERVER_NAMES);
698 memset(default_server, '\0', sizeof(default_server));
699 memset(dn_path, '\0', sizeof(dn_path));
700 memset(group_suffix, '\0', sizeof(group_suffix));
701 memset(exchange_acl, '\0', sizeof(exchange_acl));
702
703 UseSFU30 = 0;
704 UseGroupSuffix = 1;
705 UseGroupUniversal = 0;
706 SetGroupAce = 1;
707 SetPassword = 1;
708 Exchange = 0;
709 ProcessMachineContainer = 1;
710 ActiveDirectory = 1;
711
712 sprintf(group_suffix, "%s", "_group");
713 sprintf(exchange_acl, "%s", "exchange-acl");
714
715 beforec = atoi(orig_argv[2]);
716 afterc = atoi(orig_argv[3]);
717 table = orig_argv[1];
718 before = &orig_argv[4];
719 after = &orig_argv[4 + beforec];
720
721 if (afterc == 0)
722 after = NULL;
723
724 if (beforec == 0)
725 before = NULL;
726
727 if (ReadConfigFile(DomainNames[k]))
728 continue;
729
730 if(ActiveDirectory)
731 {
732 sprintf(group_ou_distribution, "OU=mail,OU=lists,OU=moira");
733 sprintf(group_ou_root, "OU=lists,OU=moira");
734 sprintf(group_ou_security, "OU=group,OU=lists,OU=moira");
735 sprintf(group_ou_neither, "OU=special,OU=lists,OU=moira");
736 sprintf(group_ou_both, "OU=mail,OU=group,OU=lists,OU=moira");
737 }
738 else
739 {
740 sprintf(group_ou_distribution, "OU=lists,OU=moira");
741 sprintf(group_ou_root, "OU=lists,OU=moira");
742 sprintf(group_ou_security, "OU=lists,OU=moira");
743 sprintf(group_ou_neither, "OU=lists,OU=moira");
744 sprintf(group_ou_both, "OU=lists,OU=moira");
745 }
746
747 OldUseSFU30 = UseSFU30;
748
749 for (i = 0; i < 5; i++)
750 {
751 ldap_handle = (LDAP *)NULL;
752 if (!(rc = ad_connect(&ldap_handle, ldap_domain, dn_path, "", "",
753 default_server, SetPassword, ServerList,
754 ldap_realm, ldap_port)))
755 {
756 com_err(whoami, 0, "connected to domain %s", DomainNames[k]);
757 break;
758 }
759 }
760
761 if ((rc) || (ldap_handle == NULL))
762 {
08d53213 763 critical_alert(whoami, "incremental",
61a2844b 764 "ldap.incr cannot connect to any server in "
765 "domain %s", DomainNames[k]);
766 continue;
767 }
768
769 for (i = 0; i < (int)strlen(table); i++)
770 table[i] = tolower(table[i]);
771
772 if (!strcmp(table, "users"))
773 do_user(ldap_handle, dn_path, ldap_domain, before, beforec, after,
774 afterc);
775 else if (!strcmp(table, "list"))
776 do_list(ldap_handle, dn_path, ldap_domain, before, beforec, after,
777 afterc);
778 else if (!strcmp(table, "imembers"))
779 do_member(ldap_handle, dn_path, ldap_domain, before, beforec, after,
780 afterc);
781 else if (!strcmp(table, "containers"))
782 do_container(ldap_handle, dn_path, ldap_domain, before, beforec, after,
783 afterc);
784 else if (!strcmp(table, "mcntmap"))
785 do_mcntmap(ldap_handle, dn_path, ldap_domain, before, beforec, after,
786 afterc);
787
788 if(SetPassword)
789 ad_kdc_disconnect();
790
791 for (i = 0; i < MAX_SERVER_NAMES; i++)
792 {
793 if (ServerList[i] != NULL)
794 {
795 free(ServerList[i]);
796 ServerList[i] = NULL;
797 }
798 }
799
800 rc = ldap_unbind_s(ldap_handle);
801 }
802
803 exit(0);
804}
805
806void do_mcntmap(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
807 char **before, int beforec, char **after, int afterc)
808{
809 char MoiraContainerName[128];
810 char ADContainerName[128];
811 char MachineName[1024];
812 char OriginalMachineName[1024];
813 long rc;
814 int DeleteMachine;
815 char MoiraContainerGroup[64];
816
817 if (!ProcessMachineContainer)
818 {
819 com_err(whoami, 0, "Process machines and containers disabled, skipping");
820 return;
821 }
822
823 DeleteMachine = 0;
824 memset(ADContainerName, '\0', sizeof(ADContainerName));
825 memset(MoiraContainerName, '\0', sizeof(MoiraContainerName));
826
827 if ((beforec == 0) && (afterc == 0))
828 return;
829
830 if (rc = moira_connect())
831 {
08d53213 832 critical_alert(whoami, "Ldap incremental",
61a2844b 833 "Error contacting Moira server : %s",
834 error_message(rc));
835 return;
836 }
837
838 if ((beforec != 0) && (afterc == 0)) /*remove a machine*/
839 {
840 strcpy(OriginalMachineName, before[OU_MACHINE_NAME]);
841 strcpy(MachineName, before[OU_MACHINE_NAME]);
842 strcpy(MoiraContainerGroup, before[OU_CONTAINER_GROUP]);
843 DeleteMachine = 1;
844 com_err(whoami, 0, "removing machine %s from %s",
845 OriginalMachineName, before[OU_CONTAINER_NAME]);
846 }
847 else if ((beforec == 0) && (afterc != 0)) /*add a machine*/
848 {
849 strcpy(OriginalMachineName, after[OU_MACHINE_NAME]);
850 strcpy(MachineName, after[OU_MACHINE_NAME]);
851 strcpy(MoiraContainerGroup, after[OU_CONTAINER_GROUP]);
852 com_err(whoami, 0, "adding machine %s to container %s",
853 OriginalMachineName, after[OU_CONTAINER_NAME]);
854 }
855 else
856 {
857 moira_disconnect();
858 return;
859 }
860
861 rc = GetMachineName(MachineName);
862
863 if (strlen(MachineName) == 0)
864 {
865 moira_disconnect();
866 com_err(whoami, 0, "Unable to find alais for machine %s in Moira",
867 OriginalMachineName);
868 return;
869 }
870
871 Moira_process_machine_container_group(MachineName, MoiraContainerGroup,
872 DeleteMachine);
873
874 if (machine_check(ldap_handle, dn_path, MachineName))
875 {
c9ef9269 876 com_err(whoami, 0, "Unable to find machine %s (alias %s) in directory.",
61a2844b 877 OriginalMachineName, MachineName);
878 moira_disconnect();
879 return;
880 }
881
882 memset(MoiraContainerName, '\0', sizeof(MoiraContainerName));
883 machine_get_moira_container(ldap_handle, dn_path, MachineName,
884 MoiraContainerName);
885
886 if (strlen(MoiraContainerName) == 0)
887 {
888 com_err(whoami, 0, "Unable to fine machine %s (alias %s) container "
889 "in Moira - moving to orphans OU.",
890 OriginalMachineName, MachineName);
891 machine_move_to_ou(ldap_handle, dn_path, MachineName,
892 orphans_machines_ou);
893 moira_disconnect();
894 return;
895 }
896
897 container_get_dn(MoiraContainerName, ADContainerName);
898
899 if (MoiraContainerName[strlen(MoiraContainerName) - 1] != '/')
900 strcat(MoiraContainerName, "/");
901
902 container_check(ldap_handle, dn_path, MoiraContainerName);
903 machine_move_to_ou(ldap_handle, dn_path, MachineName, ADContainerName);
904 moira_disconnect();
905 return;
906}
907
908void do_container(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
909 char **before, int beforec, char **after, int afterc)
910{
911 long rc;
912
913 if (!ProcessMachineContainer)
914 {
915 com_err(whoami, 0, "Process machines and containers disabled, skipping");
916 return;
917 }
918
919 if ((beforec == 0) && (afterc == 0))
920 return;
921
922 if (rc = moira_connect())
923 {
08d53213 924 critical_alert(whoami, "Ldap incremental", "Error contacting Moira server : %s",
61a2844b 925 error_message(rc));
926 return;
927 }
928
929 if ((beforec != 0) && (afterc == 0)) /*delete a new container*/
930 {
931 com_err(whoami, 0, "deleting container %s", before[CONTAINER_NAME]);
932 container_delete(ldap_handle, dn_path, beforec, before);
933 Moira_container_group_delete(before);
934 moira_disconnect();
935 return;
936 }
937
938 if ((beforec == 0) && (afterc != 0)) /*create a container*/
939 {
940 com_err(whoami, 0, "creating container %s", after[CONTAINER_NAME]);
941 container_check(ldap_handle, dn_path, after[CONTAINER_NAME]);
942 container_create(ldap_handle, dn_path, afterc, after);
943 Moira_container_group_create(after);
944 moira_disconnect();
945 return;
946 }
947
948 if (strcasecmp(before[CONTAINER_NAME], after[CONTAINER_NAME]))
949 {
950 com_err(whoami, 0, "renaming container %s to %s",
951 before[CONTAINER_NAME], after[CONTAINER_NAME]);
952 container_rename(ldap_handle, dn_path, beforec, before, afterc, after);
953 Moira_container_group_update(before, after);
954 moira_disconnect();
955 return;
956 }
957
958 com_err(whoami, 0, "updating container %s information",
959 after[CONTAINER_NAME]);
960 container_update(ldap_handle, dn_path, beforec, before, afterc, after);
961 Moira_container_group_update(before, after);
962 moira_disconnect();
963 return;
964}
965
966#define L_LIST_DESC 9
967#define L_LIST_ID 10
c95d6ec1 968#define L_LIST_NFSGROUP 11
61a2844b 969
970void do_list(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
971 char **before, int beforec, char **after, int afterc)
972{
973 int updateGroup;
974 int ProcessGroup;
975 long rc;
976 char group_membership[6];
977 char list_id[32];
978 int security_flag;
979 char filter[128];
980 char group_ou[256];
981 char before_list_id[32];
982 char before_group_membership[1];
983 int before_security_flag;
984 char before_group_ou[256];
985 LK_ENTRY *ptr = NULL;
986
987 if (beforec == 0 && afterc == 0)
988 return;
989
990 memset(list_id, '\0', sizeof(list_id));
991 memset(before_list_id, '\0', sizeof(before_list_id));
992 memset(before_group_ou, '\0', sizeof(before_group_ou));
993 memset(before_group_membership, '\0', sizeof(before_group_membership));
994 memset(group_ou, '\0', sizeof(group_ou));
995 memset(group_membership, '\0', sizeof(group_membership));
996 updateGroup = 0;
997
998 if (beforec > L_GID)
999 {
1000 if (beforec < L_LIST_ID)
1001 return;
1002 if (beforec > L_LIST_DESC)
1003 {
1004 strcpy(before_list_id, before[L_LIST_ID]);
1005 }
1006 before_security_flag = 0;
1007 get_group_membership(before_group_membership, before_group_ou,
1008 &before_security_flag, before);
1009 }
1010
1011 if (afterc > L_GID)
1012 {
1013 if (afterc < L_LIST_ID)
1014 return;
1015 if (afterc > L_LIST_DESC)
1016 {
1017 strcpy(list_id, after[L_LIST_ID]);
1018 }
1019 security_flag = 0;
1020 get_group_membership(group_membership, group_ou, &security_flag, after);
1021 }
1022
1023 if ((beforec == 0) && (afterc == 0)) /*this case should never happen*/
1024 return;
1025
1026 updateGroup = 0;
1027
1028 if (beforec)
1029 {
1030 updateGroup = 1;
1031
1032 if ((rc = process_group(ldap_handle, dn_path, before_list_id,
1033 before[L_NAME], before_group_ou,
1034 before_group_membership,
1035 before_security_flag, CHECK_GROUPS,
c95d6ec1 1036 before[L_MAILLIST], before[L_LIST_NFSGROUP])))
61a2844b 1037 {
1038 if (rc == AD_NO_GROUPS_FOUND)
1039 updateGroup = 0;
1040 else
1041 {
1042 if ((rc == AD_WRONG_GROUP_DN_FOUND) ||
1043 (rc == AD_MULTIPLE_GROUPS_FOUND))
1044 {
1045 rc = process_group(ldap_handle, dn_path, before_list_id,
1046 before[L_NAME], before_group_ou,
1047 before_group_membership,
1048 before_security_flag, CLEANUP_GROUPS,
c95d6ec1 1049 before[L_MAILLIST],
1050 before[L_LIST_NFSGROUP]);
61a2844b 1051 }
1052 if ((rc != AD_NO_GROUPS_FOUND) && (rc != 0))
1053 {
1054 com_err(whoami, 0, "Unable to process list %s",
1055 before[L_NAME]);
1056 return;
1057 }
1058 if (rc == AD_NO_GROUPS_FOUND)
1059 updateGroup = 0;
1060 }
1061 }
1062 }
1063
1064 if ((beforec != 0) && (afterc != 0))
1065 {
1066 if (((strcmp(after[L_NAME], before[L_NAME])) ||
1067 ((!strcmp(after[L_NAME], before[L_NAME])) &&
1068 (strcmp(before_group_ou, group_ou)))) &&
1069 (updateGroup == 1))
1070 {
1071 com_err(whoami, 0, "Changing list name from %s to %s",
1072 before[L_NAME], after[L_NAME]);
1073
1074 if ((strlen(before_group_ou) == 0) ||
1075 (strlen(before_group_membership) == 0) ||
1076 (strlen(group_ou) == 0) || (strlen(group_membership) == 0))
1077 {
1078 com_err(whoami, 0, "%s", "Unable to find the group OU's");
1079 return;
1080 }
1081
1082 memset(filter, '\0', sizeof(filter));
1083
1084 if ((rc = group_rename(ldap_handle, dn_path,
1085 before[L_NAME], before_group_membership,
1086 before_group_ou, before_security_flag,
1087 before[L_LIST_DESC], after[L_NAME],
1088 group_membership, group_ou, security_flag,
1089 after[L_LIST_DESC],
c95d6ec1 1090 list_id, filter, after[L_MAILLIST],
1091 after[L_LIST_NFSGROUP])))
61a2844b 1092 {
1093 if (rc != AD_NO_GROUPS_FOUND)
1094 {
1095 com_err(whoami, 0,
1096 "Unable to change list name from %s to %s",
1097 before[L_NAME], after[L_NAME]);
1098 return;
1099 }
1100 updateGroup = 0;
1101 }
1102 beforec = 0;
1103 }
1104 else
1105 beforec = 0;
1106 }
1107
1108 if (beforec)
1109 {
1110 if ((strlen(before_group_ou) == 0) ||
1111 (strlen(before_group_membership) == 0))
1112 {
1113 com_err(whoami, 0,
1114 "Unable to find the group OU for group %s", before[L_NAME]);
1115 return;
1116 }
1117
1118 com_err(whoami, 0, "Deleting group %s", before[L_NAME]);
1119 rc = group_delete(ldap_handle, dn_path, before[L_NAME],
1120 before_group_membership, before_list_id);
1121 return;
1122 }
1123
1124 if (afterc)
1125 {
1126 if (!updateGroup)
1127 {
1128 com_err(whoami, 0, "Creating group %s", after[L_NAME]);
1129
1130 if (rc = process_group(ldap_handle, dn_path, list_id, after[L_NAME],
1131 group_ou, group_membership,
1132 security_flag, CHECK_GROUPS,
c95d6ec1 1133 after[L_MAILLIST], after[L_LIST_NFSGROUP]))
61a2844b 1134 {
1135 if (rc != AD_NO_GROUPS_FOUND)
1136 {
1137 if ((rc == AD_WRONG_GROUP_DN_FOUND) ||
1138 (rc == AD_MULTIPLE_GROUPS_FOUND))
1139 {
1140 rc = process_group(ldap_handle, dn_path, list_id,
1141 after[L_NAME],
1142 group_ou, group_membership,
1143 security_flag, CLEANUP_GROUPS,
c95d6ec1 1144 after[L_MAILLIST],
1145 after[L_LIST_NFSGROUP]);
61a2844b 1146 }
1147
1148 if (rc)
1149 {
1150 com_err(whoami, 0,
1151 "Unable to create list %s", after[L_NAME]);
1152 return;
1153 }
1154 }
1155 }
1156 }
1157 else
1158 com_err(whoami, 0, "Updating group %s information", after[L_NAME]);
1159
1160 if (rc = moira_connect())
1161 {
08d53213 1162 critical_alert(whoami, "Ldap incremental",
61a2844b 1163 "Error contacting Moira server : %s",
1164 error_message(rc));
1165 return;
1166 }
1167
1168 ProcessGroup = 0;
1169
1170 if (ProcessAce(ldap_handle, dn_path, after[L_NAME], "LIST", 0,
c95d6ec1 1171 &ProcessGroup, after[L_MAILLIST], after[L_LIST_NFSGROUP]))
61a2844b 1172 return;
1173
1174 if (ProcessGroup)
1175 {
1176 if (ProcessAce(ldap_handle, dn_path, after[L_NAME], "LIST", 1,
c95d6ec1 1177 &ProcessGroup, after[L_MAILLIST],
1178 after[L_LIST_NFSGROUP]))
61a2844b 1179 return;
1180 }
1181
1182 if (make_new_group(ldap_handle, dn_path, list_id, after[L_NAME],
1183 group_ou, group_membership, security_flag,
c95d6ec1 1184 updateGroup, after[L_MAILLIST],
1185 after[L_LIST_NFSGROUP]))
61a2844b 1186 {
1187 moira_disconnect();
1188 return;
1189 }
1190
1191 if (atoi(after[L_ACTIVE]))
1192 {
1193 populate_group(ldap_handle, dn_path, after[L_NAME], group_ou,
8b76dea3 1194 group_membership, security_flag, list_id, 1);
61a2844b 1195 }
1196
1197 moira_disconnect();
1198 }
1199 return;
1200}
1201
1202#define LM_EXTRA_ACTIVE (LM_END)
1203#define LM_EXTRA_PUBLIC (LM_END+1)
1204#define LM_EXTRA_HIDDEN (LM_END+2)
1205#define LM_EXTRA_MAILLIST (LM_END+3)
1206#define LM_EXTRA_GROUP (LM_END+4)
1207#define LM_EXTRA_GID (LM_END+5)
c95d6ec1 1208#define LM_EXTRA_NFSGROUP (LM_END+6)
1209#define LMN_LIST_ID (LM_END+7)
1210#define LM_LIST_ID (LM_END+8)
1211#define LM_USER_ID (LM_END+9)
1212#define LM_EXTRA_END (LM_END+10)
61a2844b 1213
1214void do_member(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
1215 char **before, int beforec, char **after, int afterc)
1216{
1217 LK_ENTRY *group_base;
1218 int group_count;
1219 char filter[128];
1220 char *attr_array[3];
1221 char group_name[128];
1222 char user_name[128];
1223 char user_type[128];
1224 char moira_list_id[32];
1225 char moira_user_id[32];
1226 char group_membership[1];
1227 char group_ou[256];
1228 char machine_ou[256];
1229 char member[256];
1230 char *args[16];
1231 char **ptr;
1232 char *av[7];
1233 char *call_args[7];
1234 char *pUserOu;
1235 char *s;
1236 char NewMachineName[1024];
1237 int security_flag;
1238 int rc;
1239 int ProcessGroup;
1240 char *save_argv[U_END];
1241
1242 pUserOu = NULL;
1243 ptr = NULL;
1244 memset(moira_list_id, '\0', sizeof(moira_list_id));
1245 memset(moira_user_id, '\0', sizeof(moira_user_id));
1246
1247 if (afterc)
1248 {
1249 if (afterc < LM_EXTRA_GID)
1250 return;
1251
1252 if (!atoi(after[LM_EXTRA_ACTIVE]))
1253 {
1254 com_err(whoami, 0,
1255 "Unable to add %s to group %s : group not active",
1256 after[2], after[0]);
1257 return;
1258 }
1259
1260 ptr = after;
1261
1262 if (!strcasecmp(ptr[LM_TYPE], "LIST"))
1263 return;
1264
1265 strcpy(user_name, after[LM_MEMBER]);
1266 strcpy(group_name, after[LM_LIST]);
1267 strcpy(user_type, after[LM_TYPE]);
1268
1269 if (!strcasecmp(ptr[LM_TYPE], "MACHINE"))
1270 {
1271 if (afterc > LM_EXTRA_GROUP)
1272 {
1273 strcpy(moira_list_id, after[LMN_LIST_ID]);
1274 strcpy(moira_user_id, after[LM_LIST_ID]);
1275 }
1276 }
1277 else if (!strcasecmp(ptr[LM_TYPE], "USER"))
1278 {
1279 if (afterc > LMN_LIST_ID)
1280 {
1281 strcpy(moira_list_id, after[LM_LIST_ID]);
1282 strcpy(moira_user_id, after[LM_USER_ID]);
1283 }
1284 }
1285 else
1286 {
1287 if (afterc > LM_EXTRA_GID)
1288 strcpy(moira_list_id, after[LMN_LIST_ID]);
1289 }
1290 }
1291 else if (beforec)
1292 {
1293 if (beforec < LM_EXTRA_GID)
1294 return;
1295 if (!atoi(before[LM_EXTRA_ACTIVE]))
1296 {
1297 com_err(whoami, 0,
52eb0084 1298 "Unable to remove %s from group %s : group not active",
61a2844b 1299 before[2], before[0]);
1300 return;
1301 }
1302
1303 ptr = before;
1304
1305 if (!strcasecmp(ptr[LM_TYPE], "LIST"))
1306 return;
1307
1308 strcpy(user_name, before[LM_MEMBER]);
1309 strcpy(group_name, before[LM_LIST]);
1310 strcpy(user_type, before[LM_TYPE]);
1311
1312 if (!strcasecmp(ptr[LM_TYPE], "MACHINE"))
1313 {
1314 if (beforec > LM_EXTRA_GROUP)
1315 {
1316 strcpy(moira_list_id, before[LMN_LIST_ID]);
1317 strcpy(moira_user_id, before[LM_LIST_ID]);
1318 }
1319 }
1320 else if (!strcasecmp(ptr[LM_TYPE], "USER"))
1321 {
1322 if (beforec > LMN_LIST_ID)
1323 {
1324 strcpy(moira_list_id, before[LM_LIST_ID]);
1325 strcpy(moira_user_id, before[LM_USER_ID]);
1326 }
1327 }
1328 else
1329 {
1330 if (beforec > LM_EXTRA_GID)
1331 strcpy(moira_list_id, before[LMN_LIST_ID]);
1332 }
1333 }
1334
1335 if (ptr == NULL)
1336 {
1337 com_err(whoami, 0,
1338 "Unable to process group : beforec = %d, afterc = %d",
1339 beforec, afterc);
1340 return;
1341 }
1342
1343 args[L_NAME] = ptr[LM_LIST];
1344 args[L_ACTIVE] = ptr[LM_EXTRA_ACTIVE];
1345 args[L_PUBLIC] = ptr[LM_EXTRA_PUBLIC];
1346 args[L_HIDDEN] = ptr[LM_EXTRA_HIDDEN];
1347 args[L_MAILLIST] = ptr[LM_EXTRA_MAILLIST];
1348 args[L_GROUP] = ptr[LM_EXTRA_GROUP];
1349 args[L_GID] = ptr[LM_EXTRA_GID];
1350
1351 security_flag = 0;
1352 memset(group_ou, '\0', sizeof(group_ou));
1353 get_group_membership(group_membership, group_ou, &security_flag, args);
1354
1355 if (strlen(group_ou) == 0)
1356 {
1357 com_err(whoami, 0, "Unable to find the group OU for group %s",
1358 group_name);
1359 return;
1360 }
1361
1362 if (rc = process_group(ldap_handle, dn_path, moira_list_id, group_name,
1363 group_ou, group_membership, security_flag,
c95d6ec1 1364 CHECK_GROUPS, args[L_MAILLIST],
1365 args[L_LIST_NFSGROUP]))
61a2844b 1366 {
1367 if (rc != AD_NO_GROUPS_FOUND)
1368 {
1369 if (rc = process_group(ldap_handle, dn_path, moira_list_id,
1370 group_name, group_ou, group_membership,
1371 security_flag, CLEANUP_GROUPS,
c95d6ec1 1372 args[L_MAILLIST], args[L_LIST_NFSGROUP]))
61a2844b 1373 {
1374 if (rc != AD_NO_GROUPS_FOUND)
1375 {
1376 if (afterc)
1377 com_err(whoami, 0, "Unable to add %s to group %s - "
1378 "unable to process group", user_name, group_name);
1379 else
1380 com_err(whoami, 0, "Unable to remove %s from group %s - "
1381 "unable to process group", user_name, group_name);
1382 return;
1383 }
1384 }
1385 }
1386 }
1387
1388 if (rc == AD_NO_GROUPS_FOUND)
1389 {
1390 if (rc = moira_connect())
1391 {
08d53213 1392 critical_alert(whoami, "Ldap incremental",
61a2844b 1393 "Error contacting Moira server : %s",
1394 error_message(rc));
1395 return;
1396 }
1397
1398 com_err(whoami, 0, "creating group %s", group_name);
1399 ProcessGroup = 0;
1400
1401 if (ProcessAce(ldap_handle, dn_path, ptr[LM_LIST], "LIST", 0,
c95d6ec1 1402 &ProcessGroup, ptr[LM_EXTRA_MAILLIST],
1403 ptr[LM_EXTRA_NFSGROUP]))
61a2844b 1404 return;
1405
1406 if (ProcessGroup)
1407 {
1408 if (ProcessAce(ldap_handle, dn_path, ptr[LM_LIST], "LIST", 1,
c95d6ec1 1409 &ProcessGroup, ptr[LM_EXTRA_MAILLIST],
1410 ptr[LM_EXTRA_NFSGROUP]))
61a2844b 1411 return;
1412 }
1413
1414 if (make_new_group(ldap_handle, dn_path, moira_list_id, ptr[LM_LIST],
1415 group_ou, group_membership, security_flag, 0,
c95d6ec1 1416 ptr[LM_EXTRA_MAILLIST], ptr[LM_EXTRA_NFSGROUP]))
61a2844b 1417 {
1418 moira_disconnect();
1419 return;
1420 }
1421
1422 if (atoi(ptr[LM_EXTRA_ACTIVE]))
1423 {
1424 populate_group(ldap_handle, dn_path, ptr[LM_LIST], group_ou,
8b76dea3 1425 group_membership, security_flag, moira_list_id, 1);
61a2844b 1426 }
1427
1428 moira_disconnect();
1429 }
1430
1431 rc = 0;
1432
1433 if (beforec)
1434 {
1435 com_err(whoami, 0, "removing user %s from list %s", user_name,
1436 group_name);
1437 pUserOu = user_ou;
e8332ac3 1438
61a2844b 1439 if (!strcasecmp(ptr[LM_TYPE], "MACHINE"))
1440 {
e8332ac3 1441 if (!ProcessMachineContainer)
1442 {
1443 com_err(whoami, 0, "Process machines and containers disabled, "
1444 "skipping");
1445 return;
1446 }
1447
61a2844b 1448 memset(machine_ou, '\0', sizeof(machine_ou));
1449 memset(NewMachineName, '\0', sizeof(NewMachineName));
1450 if (get_machine_ou(ldap_handle, dn_path, ptr[LM_MEMBER],
1451 machine_ou, NewMachineName))
1452 return;
1453 if (ptr[LM_MEMBER] != NULL)
1454 free(ptr[LM_MEMBER]);
1455 ptr[LM_MEMBER] = strdup(NewMachineName);
1456 pUserOu = machine_ou;
1457 }
1458
1459 if (!strcasecmp(ptr[LM_TYPE], "STRING"))
1460 {
1461 strcpy(member, ptr[LM_MEMBER]);
1462
1463 if (Exchange)
1464 {
1465 if((s = strchr(member, '@')) == (char *) NULL)
7be1cfa9 1466 return;
61a2844b 1467
1468 if(!strncasecmp(&member[strlen(member) - 6], ".LOCAL", 6))
7be1cfa9 1469 return;
61a2844b 1470 }
1471
1472 if (contact_create(ldap_handle, dn_path, ptr[LM_MEMBER],
1473 contact_ou))
1474 return;
1475
1476 pUserOu = contact_ou;
1477 }
1478 else if (!strcasecmp(ptr[LM_TYPE], "KERBEROS"))
1479 {
1480 if (contact_create(ldap_handle, dn_path, ptr[LM_MEMBER],
1481 kerberos_ou))
1482 return;
1483
1484 pUserOu = kerberos_ou;
1485 }
1486
1487 if (rc = moira_connect()) {
08d53213 1488 critical_alert(whoami, "Ldap incremental",
61a2844b 1489 "Error contacting Moira server : %s",
1490 error_message(rc));
1491 return;
1492 }
1493
1494 if (rc = populate_group(ldap_handle, dn_path, group_name,
1495 group_ou, group_membership,
8b76dea3 1496 security_flag, moira_list_id, 0))
61a2844b 1497 com_err(whoami, 0, "Unable to remove %s from group %s", user_name,
1498 group_name);
1499
1500 moira_disconnect();
61a2844b 1501
8b76dea3 1502 if (rc = member_remove(ldap_handle, dn_path, group_name,
c95d6ec1 1503 group_ou, group_membership,
1504 escape_string(ptr[LM_MEMBER]),
8b76dea3 1505 pUserOu, moira_list_id))
1506 com_err(whoami, 0, "Unable to remove %s from group %s", user_name,
1507 group_name);
1508
61a2844b 1509 return;
1510 }
1511
1512 com_err(whoami, 0, "Adding %s to list %s", user_name, group_name);
1513 pUserOu = user_ou;
1514
1515 if (!strcasecmp(ptr[LM_TYPE], "MACHINE"))
1516 {
1517 memset(machine_ou, '\0', sizeof(machine_ou));
1518 memset(NewMachineName, '\0', sizeof(NewMachineName));
1519
1520 if (get_machine_ou(ldap_handle, dn_path, ptr[LM_MEMBER], machine_ou,
1521 NewMachineName))
1522 return;
1523
1524 if (ptr[LM_MEMBER] != NULL)
1525 free(ptr[LM_MEMBER]);
1526
1527 ptr[LM_MEMBER] = strdup(NewMachineName);
1528 pUserOu = machine_ou;
1529 }
1530 else if (!strcasecmp(ptr[LM_TYPE], "STRING"))
1531 {
1532 strcpy(member, ptr[LM_MEMBER]);
1533
1534 if (Exchange)
1535 {
1536 if((s = strchr(member, '@')) == (char *) NULL)
7be1cfa9 1537 return;
61a2844b 1538
1539 if(!strncasecmp(&member[strlen(member) - 6], ".LOCAL", 6))
7be1cfa9 1540 return;
61a2844b 1541 }
1542
1543 if (contact_create(ldap_handle, dn_path, ptr[LM_MEMBER],
1544 contact_ou))
1545 return;
1546
1547 pUserOu = contact_ou;
1548 }
1549 else if (!strcasecmp(ptr[LM_TYPE], "KERBEROS"))
1550 {
1551 if (contact_create(ldap_handle, dn_path, ptr[LM_MEMBER],
1552 kerberos_ou))
1553 return;
1554
1555 pUserOu = kerberos_ou;
1556 }
1557 else if (!strcasecmp(ptr[LM_TYPE], "USER"))
1558 {
1559 if ((rc = check_user(ldap_handle, dn_path, ptr[LM_MEMBER],
1560 moira_user_id)) == AD_NO_USER_FOUND)
1561 {
1562 if (rc = moira_connect())
1563 {
08d53213 1564 critical_alert(whoami, "Ldap incremental",
61a2844b 1565 "Error connection to Moira : %s",
1566 error_message(rc));
1567 return;
1568 }
1569
1570 com_err(whoami, 0, "creating user %s", ptr[LM_MEMBER]);
1571 av[0] = ptr[LM_MEMBER];
1572 call_args[0] = (char *)ldap_handle;
1573 call_args[1] = dn_path;
1574 call_args[2] = moira_user_id;
1575 call_args[3] = NULL;
1576
1577 callback_rc = 0;
1578
1579 if (Exchange)
1580 {
1581 group_count = 0;
1582 group_base = NULL;
1583
1584 sprintf(filter, "(&(objectClass=group)(cn=%s))", ptr[LM_MEMBER]);
1585 attr_array[0] = "cn";
1586 attr_array[1] = NULL;
1587 if ((rc = linklist_build(ldap_handle, dn_path, filter,
1588 attr_array, &group_base, &group_count,
1589 LDAP_SCOPE_SUBTREE)) != 0)
1590 {
1591 com_err(whoami, 0, "Unable to process user %s : %s",
1592 ptr[LM_MEMBER], ldap_err2string(rc));
1593 return;
1594 }
1595
1596 if (group_count)
1597 {
1598 com_err(whoami, 0, "Object already exists with name %s",
1599 ptr[LM_MEMBER]);
1600 return;
1601 }
1602
1603 linklist_free(group_base);
1604 group_count = 0;
1605 group_base = NULL;
1606 }
1607
1608 if (rc = mr_query("get_user_account_by_login", 1, av,
1609 save_query_info, save_argv))
1610 {
1611 moira_disconnect();
1612 com_err(whoami, 0, "Unable to create user %s : %s",
1613 ptr[LM_MEMBER], error_message(rc));
1614 return;
1615 }
1616
1617 if (rc = user_create(U_END, save_argv, call_args))
1618 {
1619 moira_disconnect();
1620 com_err(whoami, 0, "Unable to create user %s", ptr[LM_MEMBER]);
1621 return;
1622 }
1623
1624 if (callback_rc)
1625 {
1626 moira_disconnect();
1627 com_err(whoami, 0, "Unable to create user %s", ptr[LM_MEMBER]);
1628 return;
1629 }
1630 }
1631 else
1632 {
1633 if (rc != 0)
1634 return;
1635 }
1636 pUserOu = user_ou;
1637 }
1638
1639 if (rc = moira_connect()) {
08d53213 1640 critical_alert(whoami, "Ldap incremental",
61a2844b 1641 "Error contacting Moira server : %s",
1642 error_message(rc));
1643 return;
1644 }
1645
1646 if (rc = populate_group(ldap_handle, dn_path, group_name,
1647 group_ou, group_membership, security_flag,
8b76dea3 1648 moira_list_id, 0))
61a2844b 1649 com_err(whoami, 0, "Unable to add %s to group %s", user_name,
1650 group_name);
1651
1652 moira_disconnect();
1653
8b76dea3 1654 if (rc = member_add(ldap_handle, dn_path, group_name,
c95d6ec1 1655 group_ou, group_membership,
1656 escape_string(ptr[LM_MEMBER]),
8b76dea3 1657 pUserOu, moira_list_id))
1658 com_err(whoami, 0, "Unable to add %s to group %s", user_name, group_name);
61a2844b 1659
1660 return;
1661}
1662
61a2844b 1663#define U_USER_ID 10
1664#define U_HOMEDIR 11
1665#define U_PROFILEDIR 12
c95d6ec1 1666#define U_POTYPE 13
61a2844b 1667
1668void do_user(LDAP *ldap_handle, char *dn_path, char *ldap_hostname,
1669 char **before, int beforec, char **after,
1670 int afterc)
1671{
1672 LK_ENTRY *group_base;
1673 int group_count;
1674 char filter[128];
1675 char *attr_array[3];
1676 int rc;
1677 char *av[7];
1678 char after_user_id[32];
1679 char before_user_id[32];
1680 char *call_args[7];
1681 char *save_argv[U_END];
1682
1683 if ((beforec == 0) && (afterc == 0))
1684 return;
1685
1686 memset(after_user_id, '\0', sizeof(after_user_id));
1687 memset(before_user_id, '\0', sizeof(before_user_id));
1688
1689 if (beforec > U_USER_ID)
1690 strcpy(before_user_id, before[U_USER_ID]);
1691
1692 if (afterc > U_USER_ID)
1693 strcpy(after_user_id, after[U_USER_ID]);
1694
1695 if ((beforec == 0) && (afterc == 0)) /*this case should never happen */
1696 return;
1697
1698 if ((beforec == 0) && (afterc != 0))
1699 {
1700 /*this case only happens when the account*/
1701 /*account is first created but not usable*/
1702
1703 com_err(whoami, 0, "Unable to process user %s because the user account "
1704 "is not yet usable", after[U_NAME]);
1705 return;
1706 }
1707
1708 /*this case only happens when the account is expunged */
1709
1710 if ((beforec != 0) && (afterc == 0))
1711 {
1712 if (atoi(before[U_STATE]) == 0)
1713 {
c9ef9269 1714 com_err(whoami, 0, "expunging user %s from directory",
1715 before[U_NAME]);
61a2844b 1716 user_delete(ldap_handle, dn_path, before[U_NAME], before_user_id);
1717 }
1718 else
1719 {
1720 com_err(whoami, 0, "Unable to process because user %s has been "
1721 "previously expungeded", before[U_NAME]);
1722 }
1723 return;
1724 }
1725
1726 /*process anything that gets here*/
1727
1728 if ((rc = check_user(ldap_handle, dn_path, before[U_NAME],
1729 before_user_id)) == AD_NO_USER_FOUND)
1730 {
1731 if (!check_string(after[U_NAME]))
1732 return;
1733
1734 if (rc = moira_connect())
1735 {
08d53213 1736 critical_alert(whoami, "Ldap incremental",
61a2844b 1737 "Error connection to Moira : %s",
1738 error_message(rc));
1739 return;
1740 }
1741
1742 com_err(whoami, 0, "creating user %s", after[U_NAME]);
1743
1744 av[0] = after[U_NAME];
1745 call_args[0] = (char *)ldap_handle;
1746 call_args[1] = dn_path;
1747 call_args[2] = after_user_id;
1748 call_args[3] = NULL;
1749 callback_rc = 0;
1750
1751 if (Exchange)
1752 {
1753 group_count = 0;
1754 group_base = NULL;
1755
1756 sprintf(filter, "(&(objectClass=group)(cn=%s))", after[U_NAME]);
1757 attr_array[0] = "cn";
1758 attr_array[1] = NULL;
1759
1760 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
1761 &group_base, &group_count,
1762 LDAP_SCOPE_SUBTREE)) != 0)
1763 {
1764 com_err(whoami, 0, "Unable to process user %s : %s",
1765 after[U_NAME], ldap_err2string(rc));
1766 return;
1767 }
1768
1769 if (group_count >= 1)
1770 {
1771 com_err(whoami, 0, "Object already exists with name %s",
1772 after[U_NAME]);
1773 return;
1774 }
1775
1776 linklist_free(group_base);
1777 group_count = 0;
1778 group_base = NULL;
1779 }
1780
1781 if (rc = mr_query("get_user_account_by_login", 1, av,
1782 save_query_info, save_argv))
1783 {
1784 moira_disconnect();
1785 com_err(whoami, 0, "Unable to create user %s : %s",
1786 after[U_NAME], error_message(rc));
1787 return;
1788 }
1789
1790 if (rc = user_create(U_END, save_argv, call_args))
1791 {
1792 com_err(whoami, 0, "Unable to create user %s : %s",
1793 after[U_NAME], error_message(rc));
1794 return;
1795 }
1796
1797 if (callback_rc)
1798 {
1799 moira_disconnect();
1800 com_err(whoami, 0, "Unable to create user %s", after[U_NAME]);
1801 return;
1802 }
1803
1804 return;
1805 }
1806 else
1807 {
1808 if (rc != 0)
1809 return;
1810 }
1811
1812 if (strcmp(before[U_NAME], after[U_NAME]))
1813 {
1814 if ((check_string(before[U_NAME])) && (check_string(after[U_NAME])))
1815 {
1816 com_err(whoami, 0, "changing user %s to %s",
1817 before[U_NAME], after[U_NAME]);
1818
1819 if ((rc = user_rename(ldap_handle, dn_path, before[U_NAME],
1820 after[U_NAME])) != LDAP_SUCCESS)
1821 {
1822 return;
1823 }
1824 }
1825 }
1826
1827 com_err(whoami, 0, "updating user %s information", after[U_NAME]);
c95d6ec1 1828
61a2844b 1829 rc = user_update(ldap_handle, dn_path, after[U_NAME],
1830 after[U_UID], after[U_MITID],
1831 after_user_id, atoi(after[U_STATE]),
1832 after[U_HOMEDIR], after[U_PROFILEDIR],
1833 after[U_FIRST], after[U_MIDDLE], after[U_LAST],
1834 after[U_SHELL], after[U_CLASS]);
1835
1836 return;
1837}
1838
1839int construct_newvalues(LK_ENTRY *linklist_base, int modvalue_count,
1840 char *oldValue, char *newValue,
1841 char ***modvalues, int type)
1842{
1843 LK_ENTRY *linklist_ptr;
1844 int i;
1845 char *cPtr;
1846
1847 if (((*modvalues) = calloc(1,
1848 (modvalue_count + 1) * sizeof(char *))) == NULL)
1849 {
1850 return(1);
1851 }
1852
1853 for (i = 0; i < (modvalue_count + 1); i++)
1854 (*modvalues)[i] = NULL;
1855
1856 if (modvalue_count != 0)
1857 {
1858 linklist_ptr = linklist_base;
1859 for (i = 0; i < modvalue_count; i++)
1860 {
1861 if ((oldValue != NULL) && (newValue != NULL))
1862 {
1863 if ((cPtr = (char *)strstr(linklist_ptr->value, oldValue))
1864 != (char *)NULL)
1865 {
1866 if (type == REPLACE)
1867 {
1868 if (((*modvalues)[i] = calloc(1, strlen(newValue) + 1))
1869 == NULL)
1870 return(1);
1871 memset((*modvalues)[i], '\0', strlen(newValue) + 1);
1872 strcpy((*modvalues)[i], newValue);
1873 }
1874 else
1875 {
1876 if (((*modvalues)[i] = calloc(1,
1877 (int)(cPtr - linklist_ptr->value) +
1878 (linklist_ptr->length -
1879 strlen(oldValue)) +
1880 strlen(newValue) + 1)) == NULL)
1881 return(1);
1882 memset((*modvalues)[i], '\0',
1883 (int)(cPtr - linklist_ptr->value) +
1884 (linklist_ptr->length - strlen(oldValue)) +
1885 strlen(newValue) + 1);
1886 memcpy((*modvalues)[i], linklist_ptr->value,
1887 (int)(cPtr - linklist_ptr->value));
1888 strcat((*modvalues)[i], newValue);
1889 strcat((*modvalues)[i],
1890 &linklist_ptr->value[(int)(cPtr -
1891 linklist_ptr->value) + strlen(oldValue)]);
1892 }
1893 }
1894 else
1895 {
1896 (*modvalues)[i] = calloc(1, linklist_ptr->length + 1);
1897 memset((*modvalues)[i], '\0', linklist_ptr->length + 1);
1898 memcpy((*modvalues)[i], linklist_ptr->value,
1899 linklist_ptr->length);
1900 }
1901 }
1902 else
1903 {
1904 (*modvalues)[i] = calloc(1, linklist_ptr->length + 1);
1905 memset((*modvalues)[i], '\0', linklist_ptr->length + 1);
1906 memcpy((*modvalues)[i], linklist_ptr->value,
1907 linklist_ptr->length);
1908 }
1909 linklist_ptr = linklist_ptr->next;
1910 }
1911 (*modvalues)[i] = NULL;
1912 }
1913 return(0);
1914}
1915
1916
1917int linklist_build(LDAP *ldap_handle, char *dn_path, char *search_exp,
1918 char **attr_array, LK_ENTRY **linklist_base,
1919 int *linklist_count, unsigned long ScopeType)
1920{
1921 ULONG rc;
1922 LDAPMessage *ldap_entry;
1923
1924 rc = 0;
1925 ldap_entry = NULL;
1926 (*linklist_base) = NULL;
1927 (*linklist_count) = 0;
1928
1929 if ((rc = ldap_search_s(ldap_handle, dn_path, ScopeType,
1930 search_exp, attr_array, 0,
1931 &ldap_entry)) != LDAP_SUCCESS)
1932 {
1933 if (rc != LDAP_SIZELIMIT_EXCEEDED)
1934 return(0);
1935 }
1936
1937 rc = retrieve_entries(ldap_handle, ldap_entry, linklist_base,
1938 linklist_count);
1939
1940 ldap_msgfree(ldap_entry);
1941 return(rc);
1942}
1943
1944int retrieve_entries(LDAP *ldap_handle, LDAPMessage *ldap_entry,
1945 LK_ENTRY **linklist_base, int *linklist_count)
1946{
1947 char distinguished_name[1024];
1948 LK_ENTRY *linklist_ptr;
1949 int rc;
1950
1951 if ((ldap_entry = ldap_first_entry(ldap_handle, ldap_entry)) == NULL)
1952 return(0);
1953
1954 memset(distinguished_name, '\0', sizeof(distinguished_name));
1955 get_distinguished_name(ldap_handle, ldap_entry, distinguished_name);
1956
1957 if ((rc = retrieve_attributes(ldap_handle, ldap_entry, distinguished_name,
1958 linklist_base)) != 0)
1959 return(rc);
1960
1961 while ((ldap_entry = ldap_next_entry(ldap_handle, ldap_entry)) != NULL)
1962 {
1963 memset(distinguished_name, '\0', sizeof(distinguished_name));
1964 get_distinguished_name(ldap_handle, ldap_entry, distinguished_name);
1965
1966 if ((rc = retrieve_attributes(ldap_handle, ldap_entry,
1967 distinguished_name, linklist_base)) != 0)
1968 return(rc);
1969 }
1970
1971 linklist_ptr = (*linklist_base);
1972 (*linklist_count) = 0;
1973
1974 while (linklist_ptr != NULL)
1975 {
1976 ++(*linklist_count);
1977 linklist_ptr = linklist_ptr->next;
1978 }
1979
1980 return(0);
1981}
1982
1983int retrieve_attributes(LDAP *ldap_handle, LDAPMessage *ldap_entry,
1984 char *distinguished_name, LK_ENTRY **linklist_current)
1985{
1986 char *Attribute;
1987 BerElement *ptr;
1988
1989 ptr = NULL;
1990
1991 if ((Attribute = ldap_first_attribute(ldap_handle, ldap_entry,
1992 &ptr)) != NULL)
1993 {
1994 retrieve_values(ldap_handle, ldap_entry, Attribute, distinguished_name,
1995 linklist_current);
1996 ldap_memfree(Attribute);
1997 while ((Attribute = ldap_next_attribute(ldap_handle, ldap_entry,
1998 ptr)) != NULL)
1999 {
2000 retrieve_values(ldap_handle, ldap_entry, Attribute,
2001 distinguished_name, linklist_current);
2002 ldap_memfree(Attribute);
2003 }
2004 }
2005
2006 ldap_ber_free(ptr, 0);
2007
2008 return(0);
2009}
2010
2011int retrieve_values(LDAP *ldap_handle, LDAPMessage *ldap_entry,
2012 char *Attribute, char *distinguished_name,
2013 LK_ENTRY **linklist_current)
2014{
2015 char **str_value;
2016 char temp[256];
2017 void **Ptr;
2018 int use_bervalue;
2019 LK_ENTRY *linklist_previous;
2020 LDAP_BERVAL **ber_value;
2021 DWORD ber_length;
2022
2023#ifdef LDAP_DEBUG
2024 SID *sid;
2025 GUID *guid;
2026 int i;
2027 int intValue;
2028 DWORD *subauth;
2029 SID_IDENTIFIER_AUTHORITY *sid_auth;
2030 unsigned char *subauth_count;
2031#endif /*LDAP_BEGUG*/
2032
2033 use_bervalue = 0;
2034 memset(temp, '\0', sizeof(temp));
2035
2036 if ((!strcmp(Attribute, "objectSid")) ||
2037 (!strcmp(Attribute, "objectGUID")))
2038 use_bervalue = 1;
2039
2040 if (use_bervalue)
2041 {
2042 ber_value = ldap_get_values_len(ldap_handle, ldap_entry, Attribute);
2043 Ptr = (void **)ber_value;
2044 str_value = NULL;
2045 }
2046 else
2047 {
2048 str_value = ldap_get_values(ldap_handle, ldap_entry, Attribute);
2049 Ptr = (void **)str_value;
2050 ber_value = NULL;
2051 }
2052
2053 if (Ptr != NULL)
2054 {
2055 for (; *Ptr; Ptr++)
2056 {
2057 if ((linklist_previous = calloc(1, sizeof(LK_ENTRY))) == NULL)
2058 return(1);
2059
2060 memset(linklist_previous, '\0', sizeof(LK_ENTRY));
2061 linklist_previous->next = (*linklist_current);
2062 (*linklist_current) = linklist_previous;
2063
2064 if (((*linklist_current)->attribute = calloc(1,
2065 strlen(Attribute) + 1)) == NULL)
2066 return(1);
2067
2068 memset((*linklist_current)->attribute, '\0', strlen(Attribute) + 1);
2069 strcpy((*linklist_current)->attribute, Attribute);
2070
2071 if (use_bervalue)
2072 {
2073 ber_length = (*(LDAP_BERVAL **)Ptr)->bv_len;
2074
2075 if (((*linklist_current)->value = calloc(1, ber_length)) == NULL)
2076 return(1);
2077
2078 memset((*linklist_current)->value, '\0', ber_length);
2079 memcpy((*linklist_current)->value,
2080 (*(LDAP_BERVAL **)Ptr)->bv_val, ber_length);
2081 (*linklist_current)->length = ber_length;
2082 }
2083 else
2084 {
2085 if (((*linklist_current)->value = calloc(1,
2086 strlen(*Ptr) + 1)) == NULL)
2087 return(1);
2088
2089 memset((*linklist_current)->value, '\0', strlen(*Ptr) + 1);
2090 (*linklist_current)->length = strlen(*Ptr);
2091 strcpy((*linklist_current)->value, *Ptr);
2092 }
2093
2094 (*linklist_current)->ber_value = use_bervalue;
2095
2096 if (((*linklist_current)->dn = calloc(1,
2097 strlen(distinguished_name) + 1)) == NULL)
2098 return(1);
2099
2100 memset((*linklist_current)->dn, '\0',
2101 strlen(distinguished_name) + 1);
2102 strcpy((*linklist_current)->dn, distinguished_name);
2103
2104#ifdef LDAP_DEBUG
2105 if (!strcmp(Attribute, "objectGUID"))
2106 {
2107 guid = (GUID *)((*linklist_current)->value);
2108 sprintf(temp,
2109 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
2110 guid->Data1, guid->Data2, guid->Data3,
2111 guid->Data4[0], guid->Data4[1], guid->Data4[2],
2112 guid->Data4[3], guid->Data4[4], guid->Data4[5],
2113 guid->Data4[6], guid->Data4[7]);
2114 print_to_screen(" %20s : {%s}\n", Attribute, temp);
2115 }
2116 else if (!strcmp(Attribute, "objectSid"))
2117 {
2118 sid = (SID *)((*(LDAP_BERVAL **)Ptr)->bv_val);
2119
2120#ifdef _WIN32
2121 print_to_screen(" Revision = %d\n", sid->Revision);
2122 print_to_screen(" SID Identifier Authority:\n");
2123 sid_auth = &sid->IdentifierAuthority;
2124 if (sid_auth->Value[0])
2125 print_to_screen(" SECURITY_NULL_SID_AUTHORITY\n");
2126 else if (sid_auth->Value[1])
2127 print_to_screen(" SECURITY_WORLD_SID_AUTHORITY\n");
2128 else if (sid_auth->Value[2])
2129 print_to_screen(" SECURITY_LOCAL_SID_AUTHORITY\n");
2130 else if (sid_auth->Value[3])
2131 print_to_screen(" SECURITY_CREATOR_SID_AUTHORITY\n");
2132 else if (sid_auth->Value[5])
2133 print_to_screen(" SECURITY_NT_AUTHORITY\n");
2134 else
2135 print_to_screen(" UNKNOWN SID AUTHORITY\n");
2136 subauth_count = GetSidSubAuthorityCount(sid);
2137 print_to_screen(" SidSubAuthorityCount = %d\n",
2138 *subauth_count);
2139 print_to_screen(" SidSubAuthority:\n");
2140 for (i = 0; i < *subauth_count; i++)
2141 {
2142 if ((subauth = GetSidSubAuthority(sid, i)) != NULL)
2143 print_to_screen(" %u\n", *subauth);
2144 }
2145#endif
2146 }
2147 else if ((!memcmp(Attribute, "userAccountControl",
2148 strlen("userAccountControl"))) ||
2149 (!memcmp(Attribute, "sAMAccountType",
2150 strlen("sAmAccountType"))))
2151 {
2152 intValue = atoi(*Ptr);
2153 print_to_screen(" %20s : %ld\n",Attribute, intValue);
2154
2155 if (!memcmp(Attribute, "userAccountControl",
2156 strlen("userAccountControl")))
2157 {
2158 if (intValue & UF_ACCOUNTDISABLE)
2159 print_to_screen(" %20s : %s\n",
2160 "", "Account disabled");
2161 else
2162 print_to_screen(" %20s : %s\n",
2163 "", "Account active");
2164 if (intValue & UF_HOMEDIR_REQUIRED)
2165 print_to_screen(" %20s : %s\n",
2166 "", "Home directory required");
2167 if (intValue & UF_LOCKOUT)
2168 print_to_screen(" %20s : %s\n",
2169 "", "Account locked out");
2170 if (intValue & UF_PASSWD_NOTREQD)
2171 print_to_screen(" %20s : %s\n",
2172 "", "No password required");
2173 if (intValue & UF_PASSWD_CANT_CHANGE)
2174 print_to_screen(" %20s : %s\n",
2175 "", "Cannot change password");
2176 if (intValue & UF_TEMP_DUPLICATE_ACCOUNT)
2177 print_to_screen(" %20s : %s\n",
2178 "", "Temp duplicate account");
2179 if (intValue & UF_NORMAL_ACCOUNT)
2180 print_to_screen(" %20s : %s\n",
2181 "", "Normal account");
2182 if (intValue & UF_INTERDOMAIN_TRUST_ACCOUNT)
2183 print_to_screen(" %20s : %s\n",
2184 "", "Interdomain trust account");
2185 if (intValue & UF_WORKSTATION_TRUST_ACCOUNT)
2186 print_to_screen(" %20s : %s\n",
2187 "", "Workstation trust account");
2188 if (intValue & UF_SERVER_TRUST_ACCOUNT)
2189 print_to_screen(" %20s : %s\n",
2190 "", "Server trust account");
2191 }
2192 }
2193 else
2194 {
2195 print_to_screen(" %20s : %s\n",Attribute, *Ptr);
2196 }
2197#endif /*LDAP_DEBUG*/
2198 }
2199
2200 if (str_value != NULL)
2201 ldap_value_free(str_value);
2202
2203 if (ber_value != NULL)
2204 ldap_value_free_len(ber_value);
2205 }
2206
2207 (*linklist_current) = linklist_previous;
2208
2209 return(0);
2210}
2211
2212int moira_connect(void)
2213{
2214 long rc;
2215 char HostName[64];
2216
2217 if (!mr_connections++)
2218 {
2219
2220#ifdef _WIN32
2221 memset(HostName, '\0', sizeof(HostName));
2222 strcpy(HostName, "ttsp");
2223 rc = mr_connect_cl(HostName, "ldap.incr", QUERY_VERSION, 1);
2224#else
2225 struct utsname uts;
2226 uname(&uts);
2227 rc = mr_connect_cl(uts.nodename, "ldap.incr", QUERY_VERSION, 1);
2228#endif /*WIN32*/
2229
2230 return rc;
2231 }
2232
2233 return 0;
2234}
2235
2236int check_winad(void)
2237{
2238 int i;
2239
2240 for (i = 0; file_exists(STOP_FILE); i++)
2241 {
2242 if (i > 30)
2243 {
08d53213 2244 critical_alert(whoami, "Ldap incremental",
c9ef9269 2245 "Ldap incremental failed (%s exists): %s",
61a2844b 2246 STOP_FILE, tbl_buf);
2247 return(1);
2248 }
2249
2250 sleep(60);
2251 }
2252
2253 return(0);
2254}
2255
2256int moira_disconnect(void)
2257{
2258
2259 if (!--mr_connections)
2260 {
2261 mr_disconnect();
2262 }
2263
2264 return 0;
2265}
2266
2267void get_distinguished_name(LDAP *ldap_handle, LDAPMessage *ldap_entry,
2268 char *distinguished_name)
2269{
2270 char *CName;
2271
2272 CName = ldap_get_dn(ldap_handle, ldap_entry);
2273
2274 if (CName == NULL)
2275 return;
2276
2277 strcpy(distinguished_name, CName);
2278 ldap_memfree(CName);
2279}
2280
2281int linklist_create_entry(char *attribute, char *value,
2282 LK_ENTRY **linklist_entry)
2283{
2284 (*linklist_entry) = calloc(1, sizeof(LK_ENTRY));
2285
2286 if (!(*linklist_entry))
2287 {
2288 return(1);
2289 }
2290
2291 memset((*linklist_entry), '\0', sizeof(LK_ENTRY));
2292 (*linklist_entry)->attribute = calloc(1, strlen(attribute) + 1);
2293 memset((*linklist_entry)->attribute, '\0', strlen(attribute) + 1);
2294 strcpy((*linklist_entry)->attribute, attribute);
2295 (*linklist_entry)->value = calloc(1, strlen(value) + 1);
2296 memset((*linklist_entry)->value, '\0', strlen(value) + 1);
2297 strcpy((*linklist_entry)->value, value);
2298 (*linklist_entry)->length = strlen(value);
2299 (*linklist_entry)->next = NULL;
2300
2301 return(0);
2302}
2303
2304void print_to_screen(const char *fmt, ...)
2305{
2306 va_list pvar;
2307
2308 va_start(pvar, fmt);
2309 vfprintf(stderr, fmt, pvar);
2310 fflush(stderr);
2311 va_end(pvar);
2312}
2313
2314int get_group_membership(char *group_membership, char *group_ou,
2315 int *security_flag, char **av)
2316{
2317 int maillist_flag;
2318 int group_flag;
2319
2320 maillist_flag = atoi(av[L_MAILLIST]);
2321 group_flag = atoi(av[L_GROUP]);
2322
2323 if (security_flag != NULL)
2324 (*security_flag) = 0;
2325
2326 if ((maillist_flag) && (group_flag))
2327 {
2328 if (group_membership != NULL)
2329 group_membership[0] = 'B';
2330
2331 if (security_flag != NULL)
2332 (*security_flag) = 1;
2333
2334 if (group_ou != NULL)
2335 strcpy(group_ou, group_ou_both);
2336 }
2337 else if ((!maillist_flag) && (group_flag))
2338 {
2339 if (group_membership != NULL)
2340 group_membership[0] = 'S';
2341
2342 if (security_flag != NULL)
2343 (*security_flag) = 1;
2344
2345 if (group_ou != NULL)
2346 strcpy(group_ou, group_ou_security);
2347 }
2348 else if ((maillist_flag) && (!group_flag))
2349 {
2350 if (group_membership != NULL)
2351 group_membership[0] = 'D';
2352
2353 if (group_ou != NULL)
2354 strcpy(group_ou, group_ou_distribution);
2355 }
2356 else
2357 {
2358 if (group_membership != NULL)
2359 group_membership[0] = 'N';
2360
2361 if (group_ou != NULL)
2362 strcpy(group_ou, group_ou_neither);
2363 }
2364
2365 return(0);
2366}
2367
2368int group_rename(LDAP *ldap_handle, char *dn_path,
2369 char *before_group_name, char *before_group_membership,
2370 char *before_group_ou, int before_security_flag,
2371 char *before_desc, char *after_group_name,
2372 char *after_group_membership, char *after_group_ou,
2373 int after_security_flag, char *after_desc,
c95d6ec1 2374 char *MoiraId, char *filter, char *maillist, char *nfsgroup)
61a2844b 2375{
2376 LDAPMod *mods[20];
2377 char old_dn[512];
2378 char new_dn[512];
2379 char new_dn_path[512];
2380 char sam_name[256];
2381 char mail[256];
2382 char mail_nickname[256];
2383 char proxy_address[256];
2384 char address_book[256];
2385 char *attr_array[3];
2386 char *mitMoiraId_v[] = {NULL, NULL};
2387 char *name_v[] = {NULL, NULL};
2388 char *samAccountName_v[] = {NULL, NULL};
2389 char *groupTypeControl_v[] = {NULL, NULL};
2390 char *mail_v[] = {NULL, NULL};
2391 char *proxy_address_v[] = {NULL, NULL};
2392 char *mail_nickname_v[] = {NULL, NULL};
2393 char *report_to_originator_v[] = {NULL, NULL};
2394 char *address_book_v[] = {NULL, NULL};
2395 char *legacy_exchange_dn_v[] = {NULL, NULL};
a0407f40 2396 char *null_v[] = {NULL, NULL};
61a2844b 2397 u_int groupTypeControl;
2398 char groupTypeControlStr[80];
2399 char contact_mail[256];
2400 int n;
2401 int i;
2402 int rc;
2403 LK_ENTRY *group_base;
2404 int group_count;
2405 int MailDisabled = 0;
fa8a8b32 2406 char search_filter[1024];
61a2844b 2407
2408 if(UseGroupUniversal)
2409 groupTypeControl = ADS_GROUP_TYPE_UNIVERSAL_GROUP;
2410 else
2411 groupTypeControl = ADS_GROUP_TYPE_GLOBAL_GROUP;
2412
2413 if (!check_string(before_group_name))
2414 {
2415 com_err(whoami, 0,
2416 "Unable to process invalid LDAP list name %s",
2417 before_group_name);
2418 return(AD_INVALID_NAME);
2419 }
2420
2421 if (!check_string(after_group_name))
2422 {
2423 com_err(whoami, 0,
2424 "Unable to process invalid LDAP list name %s", after_group_name);
2425 return(AD_INVALID_NAME);
2426 }
2427
2428 if (Exchange)
2429 {
2430 if(atoi(maillist))
2431 {
2432 group_count = 0;
2433 group_base = NULL;
2434
fa8a8b32 2435 sprintf(search_filter, "(&(objectClass=user)(cn=%s))",
2436 after_group_name);
61a2844b 2437 attr_array[0] = "cn";
2438 attr_array[1] = NULL;
2439
fa8a8b32 2440 if ((rc = linklist_build(ldap_handle, dn_path, search_filter,
2441 attr_array, &group_base, &group_count,
61a2844b 2442 LDAP_SCOPE_SUBTREE)) != 0)
2443 {
2444 com_err(whoami, 0, "Unable to process group %s : %s",
2445 after_group_name, ldap_err2string(rc));
2446 return(rc);
2447 }
2448
2449 if (group_count)
2450 {
2451 com_err(whoami, 0, "Object already exists with name %s",
2452 after_group_name);
2453 MailDisabled++;
2454 }
2455
2456 linklist_free(group_base);
2457 group_base = NULL;
2458 group_count = 0;
2459 }
2460 }
2461
2462 group_count = 0;
2463 group_base = NULL;
2464
2465 if (rc = ad_get_group(ldap_handle, dn_path, before_group_name,
2466 before_group_membership,
2467 MoiraId, "samAccountName", &group_base,
2468 &group_count, filter))
2469 return(rc);
2470
2471 if (group_count == 0)
2472 {
2473 return(AD_NO_GROUPS_FOUND);
2474 }
2475
2476 if (group_count != 1)
2477 {
2478 com_err(whoami, 0, "Unable to process multiple groups with "
c9ef9269 2479 "MoiraId = %s exist in the directory", MoiraId);
61a2844b 2480 return(AD_MULTIPLE_GROUPS_FOUND);
2481 }
2482
2483 strcpy(old_dn, group_base->dn);
2484
2485 linklist_free(group_base);
2486 group_base = NULL;
2487 group_count = 0;
2488 attr_array[0] = "sAMAccountName";
2489 attr_array[1] = NULL;
2490
2491 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
2492 &group_base, &group_count,
2493 LDAP_SCOPE_SUBTREE)) != 0)
2494 {
2495 com_err(whoami, 0, "Unable to get list %s dn : %s",
2496 after_group_name, ldap_err2string(rc));
2497 return(rc);
2498 }
2499
2500 if (group_count != 1)
2501 {
2502 com_err(whoami, 0,
2503 "Unable to get sAMAccountName for group %s",
2504 before_group_name);
2505 return(AD_LDAP_FAILURE);
2506 }
2507
2508 strcpy(sam_name, group_base->value);
2509 linklist_free(group_base);
2510 group_base = NULL;
2511 group_count = 0;
2512
2513 sprintf(new_dn_path, "%s,%s", after_group_ou, dn_path);
2514 sprintf(new_dn, "cn=%s", after_group_name);
2515 sprintf(mail, "%s@%s", after_group_name, lowercase(ldap_domain));
2516 sprintf(contact_mail, "%s@mit.edu", after_group_name);
2517 sprintf(proxy_address, "SMTP:%s@%s", after_group_name,
2518 lowercase(ldap_domain));
2519 sprintf(mail_nickname, "%s", after_group_name);
2520
2521 com_err(whoami, 0, "Old %s New %s,%s", old_dn, new_dn, new_dn_path);
2522
2523 if ((rc = ldap_rename_s(ldap_handle, old_dn, new_dn, new_dn_path,
2524 TRUE, NULL, NULL)) != LDAP_SUCCESS)
2525 {
2526 com_err(whoami, 0, "Unable to rename list from %s to %s : %s",
2527 before_group_name, after_group_name, ldap_err2string(rc));
2528 return(rc);
2529 }
2530
2531 name_v[0] = after_group_name;
2532
2533 if (!strncmp(&sam_name[strlen(sam_name) - strlen(group_suffix)],
2534 group_suffix, strlen(group_suffix)))
2535 {
2536 sprintf(sam_name, "%s%s", after_group_name, group_suffix);
2537 }
2538 else
2539 {
2540 com_err(whoami, 0,
2541 "Unable to rename list from %s to %s : sAMAccountName not found",
2542 before_group_name, after_group_name);
2543 return(rc);
2544 }
2545
2546 samAccountName_v[0] = sam_name;
2547
2548 if (after_security_flag)
2549 groupTypeControl |= ADS_GROUP_TYPE_SECURITY_ENABLED;
2550
2551 sprintf(groupTypeControlStr, "%ld", groupTypeControl);
2552 groupTypeControl_v[0] = groupTypeControlStr;
2553 mitMoiraId_v[0] = MoiraId;
2554
2555 sprintf(new_dn, "cn=%s,%s,%s", after_group_name, after_group_ou, dn_path);
2556 rc = attribute_update(ldap_handle, new_dn, after_desc, "description",
2557 after_group_name);
2558 n = 0;
2559 ADD_ATTR("samAccountName", samAccountName_v, LDAP_MOD_REPLACE);
2560 ADD_ATTR("displayName", name_v, LDAP_MOD_REPLACE);
2561 ADD_ATTR("mitMoiraId", mitMoiraId_v, LDAP_MOD_REPLACE);
2562 ADD_ATTR("groupType", groupTypeControl_v, LDAP_MOD_REPLACE);
2563
2564 if (Exchange)
2565 {
2566 if(atoi(maillist) && !MailDisabled && email_isvalid(mail))
2567 {
2568 mail_nickname_v[0] = mail_nickname;
2569 proxy_address_v[0] = proxy_address;
2570 mail_v[0] = mail;
2571 report_to_originator_v[0] = "TRUE";
2572
2573 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_REPLACE);
2574 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
2575 ADD_ATTR("proxyAddresses", proxy_address_v, LDAP_MOD_REPLACE);
2576 ADD_ATTR("reportToOriginator", report_to_originator_v,
2577 LDAP_MOD_REPLACE);
2578 }
2579 else
2580 {
2581 mail_nickname_v[0] = NULL;
2582 proxy_address_v[0] = NULL;
2583 mail_v[0] = NULL;
2584 legacy_exchange_dn_v[0] = NULL;
2585 address_book_v[0] = NULL;
2586 report_to_originator_v[0] = NULL;
2587
2588 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_REPLACE);
2589 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
2590 ADD_ATTR("proxyAddresses", proxy_address_v, LDAP_MOD_REPLACE);
2591 ADD_ATTR("legacyExchangeDN", legacy_exchange_dn_v, LDAP_MOD_REPLACE);
2592 ADD_ATTR("showInAddressBook", address_book_v, LDAP_MOD_REPLACE);
2593 ADD_ATTR("reportToOriginator", report_to_originator_v,
2594 LDAP_MOD_REPLACE);
2595 }
2596 }
2597 else
2598 {
2599 if(atoi(maillist) && email_isvalid(contact_mail))
2600 {
2601 mail_v[0] = contact_mail;
2602 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
a0407f40 2603
2604 if(!ActiveDirectory)
2605 {
2606 null_v[0] = "/dev/null";
2607 ADD_ATTR("mailRoutingAddress", null_v, LDAP_MOD_REPLACE);
c95d6ec1 2608 ADD_ATTR("mitMoiraMail", mail_v, LDAP_MOD_REPLACE);
a0407f40 2609 }
61a2844b 2610 }
2611 }
2612
2613 mods[n] = NULL;
2614
2615 if ((rc = ldap_modify_s(ldap_handle, new_dn, mods)) != LDAP_SUCCESS)
2616 {
2617 com_err(whoami, 0,
2618 "Unable to modify list data for %s after renaming: %s",
2619 after_group_name, ldap_err2string(rc));
2620 }
2621
2622 for (i = 0; i < n; i++)
2623 free(mods[i]);
2624
2625 return(rc);
2626}
2627
2628int group_create(int ac, char **av, void *ptr)
2629{
2630 LDAPMod *mods[20];
2631 char new_dn[256];
2632 char group_ou[256];
2633 char new_group_name[256];
2634 char sam_group_name[256];
2635 char cn_group_name[256];
2636 char mail[256];
2637 char contact_mail[256];
2638 char mail_nickname[256];
2639 char proxy_address[256];
2640 char address_book[256];
2641 char *cn_v[] = {NULL, NULL};
2642 char *objectClass_v[] = {"top", "group", NULL};
2643 char *objectClass_ldap_v[] = {"top", "microsoftComTop", "securityPrincipal",
2644 "group", "mailRecipient", NULL};
2645 char info[256];
2646 char *samAccountName_v[] = {NULL, NULL};
2647 char *altSecurityIdentities_v[] = {NULL, NULL};
2648 char *member_v[] = {NULL, NULL};
2649 char *name_v[] = {NULL, NULL};
2650 char *desc_v[] = {NULL, NULL};
2651 char *info_v[] = {NULL, NULL};
2652 char *mitMoiraId_v[] = {NULL, NULL};
2653 char *mitMoiraPublic_v[] = {NULL, NULL};
2654 char *mitMoiraHidden_v[] = {NULL, NULL};
d6232129 2655 char *mitMoiraActive_v[] = {NULL, NULL};
c95d6ec1 2656 char *mitMoiraNFSGroup_v[] = {NULL, NULL};
61a2844b 2657 char *groupTypeControl_v[] = {NULL, NULL};
2658 char *mail_v[] = {NULL, NULL};
2659 char *proxy_address_v[] = {NULL, NULL};
2660 char *mail_nickname_v[] = {NULL, NULL};
2661 char *report_to_originator_v[] = {NULL, NULL};
2662 char *address_book_v[] = {NULL, NULL};
2663 char *legacy_exchange_dn_v[] = {NULL, NULL};
2664 char *gidNumber_v[] = {NULL, NULL};
a0407f40 2665 char *null_v[] = {NULL, NULL};
61a2844b 2666 char groupTypeControlStr[80];
2667 char group_membership[1];
2668 int i;
2669 int security_flag;
2670 u_int groupTypeControl;
2671 int n;
2672 int rc;
2673 int updateGroup;
2674 int MailDisabled = 0;
2675 char **call_args;
2676 LK_ENTRY *group_base;
2677 int group_count;
2678 char filter[1024];
2679 char *attr_array[3];
2680
2681 call_args = ptr;
2682
2683 if(UseGroupUniversal)
2684 groupTypeControl = ADS_GROUP_TYPE_UNIVERSAL_GROUP;
2685 else
2686 groupTypeControl = ADS_GROUP_TYPE_GLOBAL_GROUP;
2687
2688 if (!check_string(av[L_NAME]))
2689 {
2690 com_err(whoami, 0, "Unable to process invalid LDAP list name %s",
2691 av[L_NAME]);
2692 return(AD_INVALID_NAME);
2693 }
2694
2695 updateGroup = (int)call_args[4];
2696 memset(group_ou, 0, sizeof(group_ou));
2697 memset(group_membership, 0, sizeof(group_membership));
2698 security_flag = 0;
2699
2700 get_group_membership(group_membership, group_ou, &security_flag, av);
2701
2702 strcpy(new_group_name, av[L_NAME]);
2703 sprintf(new_dn, "cn=%s,%s,%s", new_group_name, group_ou, call_args[1]);
2704 sprintf(contact_mail, "%s@mit.edu", av[L_NAME]);
2705 sprintf(mail, "%s@%s", av[L_NAME], lowercase(ldap_domain));
2706 sprintf(mail_nickname, "%s", av[L_NAME]);
2707
2708 if (security_flag)
2709 groupTypeControl |= ADS_GROUP_TYPE_SECURITY_ENABLED;
2710
2711 sprintf(sam_group_name, "%s%s", av[L_NAME], group_suffix);
2712
2713 if (!updateGroup)
2714 {
2715 sprintf(groupTypeControlStr, "%ld", groupTypeControl);
2716 groupTypeControl_v[0] = groupTypeControlStr;
2717
2718 strcpy(cn_group_name, av[L_NAME]);
2719
2720 samAccountName_v[0] = sam_group_name;
2721 name_v[0] = new_group_name;
2722 cn_v[0] = new_group_name;
2723
2724 n = 0;
2725 ADD_ATTR("cn", cn_v, LDAP_MOD_ADD);
2726
2727 if(ActiveDirectory)
2728 {
2729 ADD_ATTR("objectClass", objectClass_v, LDAP_MOD_ADD);
2730 }
2731 else
2732 {
2733 mitMoiraPublic_v[0] = av[L_PUBLIC];
2734 mitMoiraHidden_v[0] = av[L_HIDDEN];
d6232129 2735 mitMoiraActive_v[0] = av[L_ACTIVE];
c95d6ec1 2736 mitMoiraNFSGroup_v[0] = av[L_NFSGROUP];
61a2844b 2737 ADD_ATTR("objectClass", objectClass_ldap_v, LDAP_MOD_ADD);
2738 ADD_ATTR("mitMoiraPublic", mitMoiraPublic_v, LDAP_MOD_ADD);
2739 ADD_ATTR("mitMoiraHidden", mitMoiraHidden_v, LDAP_MOD_ADD);
d6232129 2740 ADD_ATTR("mitMoiraActive", mitMoiraActive_v, LDAP_MOD_ADD);
c95d6ec1 2741 ADD_ATTR("mitMoiraNFSGroup", mitMoiraNFSGroup_v, LDAP_MOD_ADD);
61a2844b 2742
2743 if(atoi(av[L_GROUP]))
2744 {
2745 gidNumber_v[0] = av[L_GID];
2746 ADD_ATTR("gidNumber", gidNumber_v, LDAP_MOD_ADD);
2747 }
2748 }
2749
2750 ADD_ATTR("sAMAccountName", samAccountName_v, LDAP_MOD_ADD);
2751 ADD_ATTR("displayName", name_v, LDAP_MOD_ADD);
2752 ADD_ATTR("name", name_v, LDAP_MOD_ADD);
2753
2754 if (Exchange)
2755 {
2756 if(atoi(av[L_MAILLIST]))
2757 {
2758 group_count = 0;
2759 group_base = NULL;
2760
2761 sprintf(filter, "(&(objectClass=user)(cn=%s))", av[L_NAME]);
2762 attr_array[0] = "cn";
2763 attr_array[1] = NULL;
2764
2765 if ((rc = linklist_build((LDAP *)call_args[0], call_args[1],
2766 filter, attr_array, &group_base,
2767 &group_count,
2768 LDAP_SCOPE_SUBTREE)) != 0)
2769 {
2770 com_err(whoami, 0, "Unable to process group %s : %s",
2771 av[L_NAME], ldap_err2string(rc));
2772 return(rc);
2773 }
2774
2775 if (group_count)
2776 {
2777 com_err(whoami, 0, "Object already exists with name %s",
2778 av[L_NAME]);
2779 MailDisabled++;
2780 }
2781
2782 linklist_free(group_base);
2783 group_base = NULL;
2784 group_count = 0;
2785 }
2786
2787 if(atoi(av[L_MAILLIST]) && !MailDisabled && email_isvalid(mail))
2788 {
2789 mail_nickname_v[0] = mail_nickname;
2790 report_to_originator_v[0] = "TRUE";
2791
2792 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_ADD);
2793 ADD_ATTR("reportToOriginator", report_to_originator_v,
2794 LDAP_MOD_ADD);
2795 }
2796 }
2797 else
2798 {
2799 if(atoi(av[L_MAILLIST]) && email_isvalid(contact_mail))
2800 {
2801 mail_v[0] = contact_mail;
2802 ADD_ATTR("mail", mail_v, LDAP_MOD_ADD);
a0407f40 2803
2804 if(!ActiveDirectory)
2805 {
2806 null_v[0] = "/dev/null";
2807 ADD_ATTR("mailRoutingAddress", null_v, LDAP_MOD_ADD);
c95d6ec1 2808 ADD_ATTR("mitMoiraMail", mail_v, LDAP_MOD_ADD);
a0407f40 2809 }
61a2844b 2810 }
2811 }
2812
2813 if (strlen(av[L_DESC]) != 0)
2814 {
2815 desc_v[0] = av[L_DESC];
2816 ADD_ATTR("description", desc_v, LDAP_MOD_ADD);
2817 }
2818
2819 ADD_ATTR("groupType", groupTypeControl_v, LDAP_MOD_ADD);
2820
2821 if (strlen(av[L_ACE_NAME]) != 0)
2822 {
2823 sprintf(info, "The Administrator of this list is: %s",
2824 av[L_ACE_NAME]);
2825 info_v[0] = info;
2826 ADD_ATTR("info", info_v, LDAP_MOD_ADD);
2827 }
2828
2829 if (strlen(call_args[5]) != 0)
2830 {
2831 mitMoiraId_v[0] = call_args[5];
2832 ADD_ATTR("mitMoiraId", mitMoiraId_v, LDAP_MOD_ADD);
2833 }
2834
2835 mods[n] = NULL;
2836
2837 rc = ldap_add_ext_s((LDAP *)call_args[0], new_dn, mods, NULL, NULL);
2838
2839 for (i = 0; i < n; i++)
2840 free(mods[i]);
2841
2842 if ((rc != LDAP_SUCCESS) && (rc != LDAP_ALREADY_EXISTS))
2843 {
c9ef9269 2844 com_err(whoami, 0, "Unable to create list %s in directory : %s",
61a2844b 2845 av[L_NAME], ldap_err2string(rc));
2846 callback_rc = rc;
2847 return(rc);
2848 }
2849 }
2850
2851 if ((rc == LDAP_ALREADY_EXISTS) || (updateGroup))
2852 {
2853 rc = attribute_update((LDAP *)call_args[0], new_dn, av[L_DESC],
2854 "description", av[L_NAME]);
2855 sprintf(info, "The Administrator of this list is: %s", av[L_ACE_NAME]);
2856
2857 rc = attribute_update((LDAP *)call_args[0], new_dn, info, "info",
2858 av[L_NAME]);
2859
2860 n = 0;
2861
2862 if (strlen(call_args[5]) != 0)
2863 {
2864 mitMoiraId_v[0] = call_args[5];
2865 ADD_ATTR("mitMoiraId", mitMoiraId_v, LDAP_MOD_REPLACE);
2866 }
2867
2868 if (!(atoi(av[L_ACTIVE])))
2869 {
2870 member_v[0] = NULL;
2871 ADD_ATTR("member", member_v, LDAP_MOD_REPLACE);
2872 }
2873
2874 if (!ActiveDirectory)
2875 {
2876 mitMoiraPublic_v[0] = av[L_PUBLIC];
2877 mitMoiraHidden_v[0] = av[L_HIDDEN];
d6232129 2878 mitMoiraActive_v[0] = av[L_ACTIVE];
c95d6ec1 2879 mitMoiraNFSGroup_v[0] = av[L_NFSGROUP];
61a2844b 2880 ADD_ATTR("mitMoiraPublic", mitMoiraPublic_v, LDAP_MOD_REPLACE);
2881 ADD_ATTR("mitMoiraHidden", mitMoiraHidden_v, LDAP_MOD_REPLACE);
d6232129 2882 ADD_ATTR("mitMoiraActive", mitMoiraActive_v, LDAP_MOD_REPLACE);
c95d6ec1 2883 ADD_ATTR("mitMoiraNFSGroup", mitMoiraNFSGroup_v, LDAP_MOD_REPLACE);
2884
61a2844b 2885 if(atoi(av[L_GROUP]))
2886 {
2887 gidNumber_v[0] = av[L_GID];
2888 ADD_ATTR("gidNumber", gidNumber_v, LDAP_MOD_REPLACE);
2889 }
2890 else
2891 {
2892 ADD_ATTR("gidNumber", gidNumber_v, LDAP_MOD_REPLACE);
2893 }
2894 }
2895
2896 if (Exchange)
2897 {
2898 if(atoi(av[L_MAILLIST]))
2899 {
2900 group_count = 0;
2901 group_base = NULL;
2902
2903 sprintf(filter, "(&(objectClass=user)(cn=%s))", av[L_NAME]);
2904 attr_array[0] = "cn";
2905 attr_array[1] = NULL;
2906
2907 if ((rc = linklist_build((LDAP *)call_args[0], call_args[1],
2908 filter, attr_array, &group_base,
2909 &group_count,
2910 LDAP_SCOPE_SUBTREE)) != 0)
2911 {
2912 com_err(whoami, 0, "Unable to process group %s : %s",
2913 av[L_NAME], ldap_err2string(rc));
2914 return(rc);
2915 }
2916
2917 if (group_count)
2918 {
2919 com_err(whoami, 0, "Object already exists with name %s",
2920 av[L_NAME]);
2921 MailDisabled++;
2922 }
2923
2924 linklist_free(group_base);
2925 group_base = NULL;
2926 group_count = 0;
2927 }
2928
2929 if (atoi(av[L_MAILLIST]) && !MailDisabled && email_isvalid(mail))
2930 {
2931 mail_nickname_v[0] = mail_nickname;
2932 report_to_originator_v[0] = "TRUE";
2933
2934 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_REPLACE);
2935 ADD_ATTR("reportToOriginator", report_to_originator_v,
2936 LDAP_MOD_REPLACE);
2937 }
2938 else
2939 {
2940 mail_v[0] = NULL;
2941 mail_nickname_v[0] = NULL;
2942 proxy_address_v[0] = NULL;
2943 legacy_exchange_dn_v[0] = NULL;
2944 address_book_v[0] = NULL;
2945 report_to_originator_v[0] = NULL;
2946
2947 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_REPLACE);
2948 ADD_ATTR("proxyAddresses", proxy_address_v, LDAP_MOD_REPLACE);
2949 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
2950 ADD_ATTR("legacyExchangeDN", legacy_exchange_dn_v,
2951 LDAP_MOD_REPLACE);
2952 ADD_ATTR("showInAddressBook", address_book_v, LDAP_MOD_REPLACE);
2953 ADD_ATTR("reportToOriginator", report_to_originator_v,
2954 LDAP_MOD_REPLACE);
2955 }
2956 }
2957 else
2958 {
2959 if (atoi(av[L_MAILLIST]) && email_isvalid(contact_mail))
2960 {
2961 mail_v[0] = contact_mail;
2962 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
a0407f40 2963
2964 if(!ActiveDirectory)
2965 {
2966 null_v[0] = "/dev/null";
2967 ADD_ATTR("mailRoutingAddress", null_v, LDAP_MOD_REPLACE);
c95d6ec1 2968 ADD_ATTR("mitMoiraMail", mail_v, LDAP_MOD_REPLACE);
a0407f40 2969 }
61a2844b 2970 }
2971 else
2972 {
2973 mail_v[0] = NULL;
2974 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
a0407f40 2975
2976 if(!ActiveDirectory)
2977 {
2978 null_v[0] = NULL;
2979 ADD_ATTR("mailRoutingAddress", null_v, LDAP_MOD_REPLACE);
c95d6ec1 2980 ADD_ATTR("mitMoiraMail", mail_v, LDAP_MOD_REPLACE);
a0407f40 2981 }
61a2844b 2982 }
2983 }
2984
2985 mods[n] = NULL;
2986 rc = LDAP_SUCCESS;
2987
2988 if (n != 0)
2989 {
2990 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
2991
2992 for (i = 0; i < n; i++)
2993 free(mods[i]);
2994
2995 if (rc != LDAP_SUCCESS)
2996 {
c9ef9269 2997 com_err(whoami, 0, "Unable to update list %s in directory : %s",
61a2844b 2998 av[L_NAME], ldap_err2string(rc));
2999 callback_rc = rc;
3000 return(rc);
3001 }
3002 }
3003 }
3004
3005 ProcessGroupSecurity((LDAP *)call_args[0], call_args[1], av[L_NAME],
3006 atoi(av[L_HIDDEN]), av[L_ACE_TYPE], av[L_ACE_NAME]);
3007
3008 return(LDAP_SUCCESS);
3009}
3010
3011int ProcessGroupSecurity(LDAP *ldap_handle, char *dn_path,
3012 char *TargetGroupName, int HiddenGroup,
3013 char *AceType, char *AceName)
3014{
3015 char filter_exp[1024];
3016 char *attr_array[5];
3017 char search_path[512];
3018 char root_ou[128];
3019 char TemplateDn[512];
3020 char TemplateSamName[128];
3021 char TargetDn[512];
3022 char TargetSamName[128];
3023 char AceSamAccountName[128];
3024 char AceDn[256];
3025 unsigned char AceSid[128];
3026 unsigned char UserTemplateSid[128];
3027 char acBERBuf[N_SD_BER_BYTES];
3028 char GroupSecurityTemplate[256];
3029 char hide_addres_lists[256];
3030 char address_book[256];
3031 char *hide_address_lists_v[] = {NULL, NULL};
3032 char *address_book_v[] = {NULL, NULL};
3033 char *owner_v[] = {NULL, NULL};
3034 int AceSidCount;
3035 int UserTemplateSidCount;
3036 int group_count;
3037 int n;
3038 int i;
3039 int rc;
3040 int nVal;
3041 ULONG dwInfo;
3042 int array_count = 0;
3043 LDAPMod *mods[20];
3044 LK_ENTRY *group_base;
3045 LDAP_BERVAL **ppsValues;
3046 LDAPControl sControl = {"1.2.840.113556.1.4.801",
3047 { N_SD_BER_BYTES, acBERBuf },
3048 TRUE
3049 };
3050 LDAPControl *apsServerControls[] = {&sControl, NULL};
3051 LDAPMessage *psMsg;
3052
3053 dwInfo = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
3054 DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
3055 BEREncodeSecurityBits(dwInfo, acBERBuf);
3056
3057 sprintf(search_path, "%s,%s", group_ou_root, dn_path);
3058 sprintf(filter_exp, "(sAMAccountName=%s%s)", TargetGroupName, group_suffix);
3059 attr_array[0] = "sAMAccountName";
3060 attr_array[1] = NULL;
3061 group_count = 0;
3062 group_base = NULL;
3063
3064 if ((rc = linklist_build(ldap_handle, search_path, filter_exp, attr_array,
3065 &group_base, &group_count,
3066 LDAP_SCOPE_SUBTREE) != 0))
3067 return(1);
3068
3069 if (group_count != 1)
3070 {
3071 linklist_free(group_base);
3072 return(1);
3073 }
3074
3075 strcpy(TargetDn, group_base->dn);
3076 strcpy(TargetSamName, group_base->value);
3077 linklist_free(group_base);
3078 group_base = NULL;
3079 group_count = 0;
3080
3081 UserTemplateSidCount = 0;
3082 memset(UserTemplateSid, '\0', sizeof(UserTemplateSid));
3083 memset(AceSamAccountName, '\0', sizeof(AceSamAccountName));
3084 memset(AceSid, '\0', sizeof(AceSid));
3085 AceSidCount = 0;
3086 group_base = NULL;
3087 group_count = 0;
3088
3089 if (strlen(AceName) != 0)
3090 {
3091 if (!strcmp(AceType, "LIST"))
3092 {
3093 sprintf(AceSamAccountName, "%s%s", AceName, group_suffix);
3094 strcpy(root_ou, group_ou_root);
3095 }
3096 else if (!strcmp(AceType, "USER"))
3097 {
3098 sprintf(AceSamAccountName, "%s", AceName);
3099 strcpy(root_ou, user_ou);
3100 }
3101
3102 if (ActiveDirectory)
3103 {
3104 if (strlen(AceSamAccountName) != 0)
3105 {
3106 sprintf(search_path, "%s", dn_path);
3107 sprintf(filter_exp, "(sAMAccountName=%s)", AceSamAccountName);
3108 attr_array[0] = "objectSid";
3109 attr_array[1] = NULL;
3110 group_count = 0;
3111 group_base = NULL;
3112
3113 if ((rc = linklist_build(ldap_handle, search_path, filter_exp,
3114 attr_array, &group_base, &group_count,
3115 LDAP_SCOPE_SUBTREE) != 0))
3116 return(1);
3117 if (group_count == 1)
3118 {
3119 strcpy(AceDn, group_base->dn);
3120 AceSidCount = group_base->length;
3121 memcpy(AceSid, group_base->value, AceSidCount);
3122 }
3123 linklist_free(group_base);
3124 group_base = NULL;
3125 group_count = 0;
3126 }
3127 }
3128 else
3129 {
3130 if (strlen(AceSamAccountName) != 0)
3131 {
3132 sprintf(search_path, "%s", dn_path);
3133 sprintf(filter_exp, "(sAMAccountName=%s)", AceSamAccountName);
3134 attr_array[0] = "samAccountName";
3135 attr_array[1] = NULL;
3136 group_count = 0;
3137 group_base = NULL;
3138
3139 if ((rc = linklist_build(ldap_handle, search_path, filter_exp,
3140 attr_array, &group_base, &group_count,
3141 LDAP_SCOPE_SUBTREE) != 0))
3142 return(1);
3143 if (group_count == 1)
3144 {
3145 strcpy(AceDn, group_base->dn);
3146 }
3147 linklist_free(group_base);
3148 group_base = NULL;
3149 group_count = 0;
3150 }
3151 }
3152 }
3153
3154 if (!ActiveDirectory)
3155 {
3156 if (strlen(AceDn) != 0)
3157 {
3158 owner_v[0] = strdup(AceDn);
3159 n = 0;
3160 ADD_ATTR("owner", owner_v, LDAP_MOD_REPLACE);
3161
3162 mods[n] = NULL;
3163
3164 rc = ldap_modify_s(ldap_handle, TargetDn, mods);
3165
3166 for (i = 0; i < n; i++)
3167 free(mods[i]);
3168
3169 if (rc != LDAP_SUCCESS)
3170 com_err(whoami, 0, "Unable to set owner for group %s : %s",
3171 TargetGroupName, ldap_err2string(rc));
3172 }
3173
3174 return(rc);
3175 }
3176
3177 if (AceSidCount == 0)
3178 {
3179 com_err(whoami, 0, "Group %s: Administrator: %s, Type: %s - does not "
c9ef9269 3180 "have a directory SID.", TargetGroupName, AceName, AceType);
61a2844b 3181 com_err(whoami, 0, " Non-admin security group template will be used.");
3182 }
3183 else
3184 {
3185 sprintf(search_path, "%s,%s", security_template_ou, dn_path);
3186 sprintf(filter_exp, "(sAMAccountName=%s)", "UserTemplate.u");
3187 attr_array[0] = "objectSid";
3188 attr_array[1] = NULL;
3189
3190 group_count = 0;
3191 group_base = NULL;
3192
3193 if ((rc = linklist_build(ldap_handle, search_path, filter_exp,
3194 attr_array, &group_base, &group_count,
3195 LDAP_SCOPE_SUBTREE) != 0))
3196 return(1);
3197
3198 if ((rc != 0) || (group_count != 1))
3199 {
3200 com_err(whoami, 0, "Unable to process user security template: %s",
3201 "UserTemplate");
3202 AceSidCount = 0;
3203 }
3204 else
3205 {
3206 UserTemplateSidCount = group_base->length;
3207 memcpy(UserTemplateSid, group_base->value, UserTemplateSidCount);
3208 }
3209 linklist_free(group_base);
3210 group_base = NULL;
3211 group_count = 0;
3212 }
3213
3214 if (HiddenGroup)
3215 {
3216 if (AceSidCount == 0)
3217 {
3218 strcpy(GroupSecurityTemplate, HIDDEN_GROUP);
3219 sprintf(filter_exp, "(sAMAccountName=%s)", HIDDEN_GROUP);
3220 }
3221 else
3222 {
3223 strcpy(GroupSecurityTemplate, HIDDEN_GROUP_WITH_ADMIN);
3224 sprintf(filter_exp, "(sAMAccountName=%s)", HIDDEN_GROUP_WITH_ADMIN);
3225 }
3226 }
3227 else
3228 {
3229 if (AceSidCount == 0)
3230 {
3231 strcpy(GroupSecurityTemplate, NOT_HIDDEN_GROUP);
3232 sprintf(filter_exp, "(sAMAccountName=%s)", NOT_HIDDEN_GROUP);
3233 }
3234 else
3235 {
3236 strcpy(GroupSecurityTemplate, NOT_HIDDEN_GROUP_WITH_ADMIN);
3237 sprintf(filter_exp, "(sAMAccountName=%s)",
3238 NOT_HIDDEN_GROUP_WITH_ADMIN);
3239 }
3240 }
3241
3242 sprintf(search_path, "%s,%s", security_template_ou, dn_path);
3243 attr_array[0] = "sAMAccountName";
3244 attr_array[1] = NULL;
3245 group_count = 0;
3246 group_base = NULL;
3247
3248 if ((rc = linklist_build(ldap_handle, search_path, filter_exp, attr_array,
3249 &group_base, &group_count,
3250 LDAP_SCOPE_SUBTREE) != 0))
3251 return(1);
3252
3253 if (group_count != 1)
3254 {
3255 linklist_free(group_base);
3256 com_err(whoami, 0, "Unable to process group security template: %s - "
3257 "security not set", GroupSecurityTemplate);
3258 return(1);
3259 }
3260
3261 strcpy(TemplateDn, group_base->dn);
3262 strcpy(TemplateSamName, group_base->value);
3263 linklist_free(group_base);
3264 group_base = NULL;
3265 group_count = 0;
3266
3267 sprintf(filter_exp, "(sAMAccountName=%s)", TemplateSamName);
3268 rc = ldap_search_ext_s(ldap_handle,
3269 TemplateDn,
3270 LDAP_SCOPE_SUBTREE,
3271 filter_exp,
3272 NULL,
3273 0,
3274 apsServerControls,
3275 NULL,
3276 NULL,
3277 0,
3278 &psMsg);
3279
3280 if ((psMsg = ldap_first_entry(ldap_handle, psMsg)) == NULL)
3281 {
3282 com_err(whoami, 0, "Unable to find group security template: %s - "
3283 "security not set", GroupSecurityTemplate);
3284 return(1);
3285 }
3286
3287 ppsValues = ldap_get_values_len(ldap_handle, psMsg, "ntSecurityDescriptor");
3288
3289 if (ppsValues == NULL)
3290 {
3291 com_err(whoami, 0, "Unable to find group security descriptor for group "
3292 "%s - security not set", GroupSecurityTemplate);
3293 return(1);
3294 }
3295
3296 if (AceSidCount != 0)
3297 {
3298 for (nVal = 0; ppsValues[nVal] != NULL; nVal++)
3299 {
3300 for (i = 0;
3301 i < (int)(ppsValues[nVal]->bv_len - UserTemplateSidCount); i++)
3302 {
3303 if (!memcmp(&ppsValues[nVal]->bv_val[i], UserTemplateSid,
3304 UserTemplateSidCount))
3305 {
3306 memcpy(&ppsValues[nVal]->bv_val[i], AceSid, AceSidCount);
3307 break;
3308 }
3309 }
3310 }
3311 }
3312
3313 n = 0;
3314 ADD_ATTR("ntSecurityDescriptor", (char **)ppsValues,
3315 LDAP_MOD_REPLACE | LDAP_MOD_BVALUES);
3316
3317 if (Exchange)
3318 {
3319 if(HiddenGroup)
3320 {
3321 hide_address_lists_v[0] = "TRUE";
3322 address_book_v[0] = NULL;
3323 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
3324 LDAP_MOD_REPLACE);
3325 ADD_ATTR("showInAddressBook", address_book_v, LDAP_MOD_REPLACE);
3326 } else {
3327 hide_address_lists_v[0] = NULL;
3328 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
3329 LDAP_MOD_REPLACE);
3330 }
3331 }
3332
3333 mods[n] = NULL;
3334
3335 rc = ldap_modify_s(ldap_handle, TargetDn, mods);
3336
3337 for (i = 0; i < n; i++)
3338 free(mods[i]);
3339
3340 ldap_value_free_len(ppsValues);
3341 ldap_msgfree(psMsg);
3342
3343 if (rc != LDAP_SUCCESS)
3344 {
3345 com_err(whoami, 0, "Unable to set security settings for group %s : %s",
3346 TargetGroupName, ldap_err2string(rc));
3347
3348 if (AceSidCount != 0)
3349 {
3350 com_err(whoami, 0,
3351 "Trying to set security for group %s without admin.",
3352 TargetGroupName);
3353
3354 if (rc = ProcessGroupSecurity(ldap_handle, dn_path, TargetGroupName,
3355 HiddenGroup, "", ""))
3356 {
3357 com_err(whoami, 0, "Unable to set security for group %s.",
3358 TargetGroupName);
3359 return(rc);
3360 }
3361 }
3362 return(rc);
3363 }
3364
3365 return(rc);
3366}
3367
3368int group_delete(LDAP *ldap_handle, char *dn_path, char *group_name,
3369 char *group_membership, char *MoiraId)
3370{
3371 LK_ENTRY *group_base;
3372 char temp[512];
3373 char filter[128];
3374 int group_count;
3375 int rc;
3376
3377 if (!check_string(group_name))
3378 {
3379 com_err(whoami, 0,
3380 "Unable to process invalid LDAP list name %s", group_name);
3381 return(AD_INVALID_NAME);
3382 }
3383
3384 memset(filter, '\0', sizeof(filter));
3385 group_count = 0;
3386 group_base = NULL;
3387 sprintf(temp, "%s,%s", group_ou_root, dn_path);
3388
3389 if (rc = ad_get_group(ldap_handle, temp, group_name,
3390 group_membership, MoiraId,
3391 "samAccountName", &group_base,
3392 &group_count, filter))
3393 return(rc);
3394
3395 if (group_count == 1)
3396 {
3397 if ((rc = ldap_delete_s(ldap_handle, group_base->dn)) != LDAP_SUCCESS)
3398 {
3399 linklist_free(group_base);
c9ef9269 3400 com_err(whoami, 0, "Unable to delete list %s from directory : %s",
61a2844b 3401 group_name, ldap_err2string(rc));
3402 return(rc);
3403 }
3404 linklist_free(group_base);
3405 }
3406 else
3407 {
3408 linklist_free(group_base);
c9ef9269 3409 com_err(whoami, 0, "Unable to find list %s in directory.", group_name);
61a2844b 3410 return(AD_NO_GROUPS_FOUND);
3411 }
3412
3413 return(0);
3414}
3415
3416int BEREncodeSecurityBits(ULONG uBits, char *pBuffer)
3417{
3418 *pBuffer++ = 0x30;
3419 *pBuffer++ = 0x03;
3420 *pBuffer++ = 0x02;
3421 *pBuffer++ = 0x00;
3422 return(N_SD_BER_BYTES);
3423}
3424
3425int process_lists(int ac, char **av, void *ptr)
3426{
3427 int rc;
3428 int security_flag;
3429 char group_ou[256];
3430 char group_membership[2];
3431 char **call_args;
3432
3433 call_args = ptr;
3434
3435 security_flag = 0;
3436 memset(group_ou, '\0', sizeof(group_ou));
3437 memset(group_membership, '\0', sizeof(group_membership));
3438 get_group_membership(group_membership, group_ou, &security_flag, av);
3439 rc = populate_group((LDAP *)call_args[0], (char *)call_args[1],
3440 av[L_NAME], group_ou, group_membership,
8b76dea3 3441 security_flag, "", 1);
61a2844b 3442
3443 return(0);
3444}
3445
3446int member_list_build(int ac, char **av, void *ptr)
3447{
3448 LK_ENTRY *linklist;
3449 char temp[1024];
3450 char **call_args;
3451 char *s;
3452 call_args = ptr;
0d2076dc 3453
61a2844b 3454 strcpy(temp, av[ACE_NAME]);
c9ef9269 3455 StringTrim(temp);
3456
61a2844b 3457 if (!check_string(temp))
3458 return(0);
3459
3460 if (!strcmp(av[ACE_TYPE], "USER"))
3461 {
3462 if (!((int)call_args[3] & MOIRA_USERS))
3463 return(0);
3464 }
3465 else if (!strcmp(av[ACE_TYPE], "STRING"))
3466 {
3467 if (Exchange)
3468 {
3469 if((s = strchr(temp, '@')) == (char *) NULL)
7be1cfa9 3470 return(0);
61a2844b 3471
3472 if(!strncasecmp(&temp[strlen(temp) - 6], ".LOCAL", 6))
7be1cfa9 3473 return(0);
61a2844b 3474 }
0d2076dc 3475
61a2844b 3476 if (!((int)call_args[3] & MOIRA_STRINGS))
3477 return(0);
0d2076dc 3478
61a2844b 3479 if (contact_create((LDAP *)call_args[0], call_args[1], temp, contact_ou))
3480 return(0);
61a2844b 3481 }
3482 else if (!strcmp(av[ACE_TYPE], "LIST"))
3483 {
3484 if (!((int)call_args[3] & MOIRA_LISTS))
3485 return(0);
3486 }
3487 else if (!strcmp(av[ACE_TYPE], "KERBEROS"))
3488 {
3489 if (!((int)call_args[3] & MOIRA_KERBEROS))
3490 return(0);
3491
3492 if (contact_create((LDAP *)call_args[0], call_args[1], temp,
3493 kerberos_ou))
3494 return(0);
3495
3496 }
e8332ac3 3497 else if (!strcmp(av[ACE_TYPE], "MACHINE"))
3498 {
3499 if (!((int)call_args[3] & MOIRA_MACHINE))
3500 return(0);
3501 }
61a2844b 3502 else
3503 return(0);
3504
3505 linklist = member_base;
3506
3507 while (linklist)
3508 {
0d2076dc 3509 if (!strcasecmp(temp, linklist->member) &&
3510 !strcasecmp(av[ACE_TYPE], linklist->type))
61a2844b 3511 return(0);
3512
3513 linklist = linklist->next;
3514 }
3515
3516 linklist = calloc(1, sizeof(LK_ENTRY));
3517 linklist->op = 1;
3518 linklist->dn = NULL;
3519 linklist->list = calloc(1, strlen(call_args[2]) + 1);
3520 strcpy(linklist->list, call_args[2]);
3521 linklist->type = calloc(1, strlen(av[ACE_TYPE]) + 1);
3522 strcpy(linklist->type, av[ACE_TYPE]);
3523 linklist->member = calloc(1, strlen(temp) + 1);
3524 strcpy(linklist->member, temp);
3525 linklist->next = member_base;
3526 member_base = linklist;
3527
3528 return(0);
3529}
3530
3531int member_remove(LDAP *ldap_handle, char *dn_path, char *group_name,
3532 char *group_ou, char *group_membership, char *user_name,
3533 char *UserOu, char *MoiraId)
3534{
3535 char distinguished_name[1024];
3536 char *modvalues[2];
3537 char temp[256];
3538 char filter[128];
3539 char *attr_array[3];
3540 int group_count;
3541 int i;
3542 int n;
3543 LDAPMod *mods[20];
3544 LK_ENTRY *group_base;
3545 ULONG rc;
3546 char *s;
3547
8b76dea3 3548 if (max_group_members && (group_members < max_group_members))
3549 return(0);
3550
61a2844b 3551 if (!check_string(group_name))
3552 return(AD_INVALID_NAME);
3553
c95d6ec1 3554 if(!contains_member(ldap_handle, dn_path, group_name, UserOu,
3555 escape_string(user_name)))
d6232129 3556 return(0);
3557
61a2844b 3558 memset(filter, '\0', sizeof(filter));
3559 group_base = NULL;
3560 group_count = 0;
3561
3562 if (rc = ad_get_group(ldap_handle, dn_path, group_name,
3563 group_membership, MoiraId,
3564 "samAccountName", &group_base,
3565 &group_count, filter))
3566 return(rc);
3567
3568 if (group_count != 1)
3569 {
c9ef9269 3570 com_err(whoami, 0, "Unable to find list %s in directory",
61a2844b 3571 group_name);
3572 linklist_free(group_base);
3573 group_base = NULL;
3574 group_count = 0;
3575 goto cleanup;
3576 }
3577
3578 strcpy(distinguished_name, group_base->dn);
3579 linklist_free(group_base);
3580 group_base = NULL;
3581 group_count = 0;
3582
3583 if(ActiveDirectory)
3584 {
3585 sprintf(temp, "CN=%s,%s,%s", user_name, UserOu, dn_path);
3586 }
3587 else
3588 {
3589 if(!strcmp(UserOu, user_ou))
3590 sprintf(temp, "uid=%s,%s,%s", user_name, UserOu, dn_path);
3591 else
3592 sprintf(temp, "CN=%s,%s,%s", user_name, UserOu, dn_path);
3593 }
3594
3595 modvalues[0] = temp;
3596 modvalues[1] = NULL;
3597
3598 n = 0;
3599 ADD_ATTR("member", modvalues, LDAP_MOD_DELETE);
3600 mods[n] = NULL;
3601 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
3602
3603 for (i = 0; i < n; i++)
3604 free(mods[i]);
3605
3606 if (rc == LDAP_UNWILLING_TO_PERFORM)
3607 rc = LDAP_SUCCESS;
3608
3609 if (rc != LDAP_SUCCESS)
3610 {
3611 com_err(whoami, 0, "Unable to modify list %s members : %s",
3612 group_name, ldap_err2string(rc));
3613 goto cleanup;
3614 }
3615
3616 if ((!strcmp(UserOu, contact_ou)) || (!strcmp(UserOu, kerberos_ou)))
3617 {
3618 if (Exchange)
3619 {
3620 if(!strcmp(UserOu, contact_ou) &&
7be1cfa9 3621 ((s = strstr(user_name,
3622 "@exchange-forwarding.mit.edu")) != (char *) NULL))
61a2844b 3623 {
3624 memset(temp, '\0', sizeof(temp));
3625 strcpy(temp, user_name);
3626 s = strchr(temp, '@');
3627 *s = '\0';
3628
3629 sprintf(filter, "(&(objectClass=user)(mailNickName=%s))", temp);
3630
3631 if ((rc = linklist_build(ldap_handle, dn_path, filter, NULL,
3632 &group_base, &group_count,
3633 LDAP_SCOPE_SUBTREE) != 0))
3634 return(rc);
3635
3636 if(group_count)
3637 goto cleanup;
3638
3639 linklist_free(group_base);
3640 group_base = NULL;
3641 group_count = 0;
3642 }
3643
3644 sprintf(filter, "(distinguishedName=%s)", temp);
3645 attr_array[0] = "memberOf";
3646 attr_array[1] = NULL;
3647
3648 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
3649 &group_base, &group_count,
3650 LDAP_SCOPE_SUBTREE) != 0))
3651 return(rc);
3652
3653
3654 if(!group_count)
3655 {
3656 com_err(whoami, 0, "Removing unreferenced object %s", temp);
3657
3658 if ((rc = ldap_delete_s(ldap_handle, temp)) != 0)
3659 return(rc);
3660 }
3661 }
3662 }
3663
3664 cleanup:
3665 return(rc);
3666}
3667
3668int member_add(LDAP *ldap_handle, char *dn_path, char *group_name,
3669 char *group_ou, char *group_membership, char *user_name,
3670 char *UserOu, char *MoiraId)
3671{
3672 char distinguished_name[1024];
3673 char *modvalues[2];
3674 char temp[256];
3675 char filter[128];
3676 int group_count;
3677 int n;
3678 int i;
3679 LDAPMod *mods[20];
3680 LK_ENTRY *group_base;
3681 ULONG rc;
3682
8b76dea3 3683 if (max_group_members && (group_members < max_group_members))
3684 return(0);
3685
61a2844b 3686 if (!check_string(group_name))
3687 return(AD_INVALID_NAME);
3688
d6232129 3689 if(contains_member(ldap_handle, dn_path, group_name, UserOu, user_name) > 0)
3690 return(0);
3691
61a2844b 3692 rc = 0;
3693 memset(filter, '\0', sizeof(filter));
3694 group_base = NULL;
3695 group_count = 0;
3696
3697 if (rc = ad_get_group(ldap_handle, dn_path, group_name,
3698 group_membership, MoiraId,
3699 "samAccountName", &group_base,
3700 &group_count, filter))
3701 return(rc);
3702
3703 if (group_count != 1)
3704 {
3705 linklist_free(group_base);
3706 group_base = NULL;
3707 group_count = 0;
c9ef9269 3708 com_err(whoami, 0, "Unable to find list %s %d in directory",
61a2844b 3709 group_name, group_count);
3710 return(AD_MULTIPLE_GROUPS_FOUND);
3711 }
3712
3713 strcpy(distinguished_name, group_base->dn);
3714 linklist_free(group_base);
3715 group_base = NULL;
3716 group_count = 0;
3717
3718 if(ActiveDirectory)
3719 {
3720 sprintf(temp, "CN=%s,%s,%s", user_name, UserOu, dn_path);
3721 }
3722 else
3723 {
3724 if(!strcmp(UserOu, user_ou))
3725 sprintf(temp, "uid=%s,%s,%s", user_name, UserOu, dn_path);
3726 else
3727 sprintf(temp, "cn=%s,%s,%s", user_name, UserOu, dn_path);
3728 }
3729
3730 modvalues[0] = temp;
3731 modvalues[1] = NULL;
3732
3733 n = 0;
3734 ADD_ATTR("member", modvalues, LDAP_MOD_ADD);
3735 mods[n] = NULL;
3736 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
3737
3738 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
3739 rc = LDAP_SUCCESS;
3740
3741 if ((!strcmp(UserOu, contact_ou)) || (!strcmp(UserOu, kerberos_ou)))
3742 {
3743 if (rc == LDAP_UNWILLING_TO_PERFORM)
3744 rc = LDAP_SUCCESS;
3745 }
3746
3747 for (i = 0; i < n; i++)
3748 free(mods[i]);
3749
3750 if (rc != LDAP_SUCCESS)
3751 {
3752 com_err(whoami, 0, "Unable to add %s to list %s as a member : %s",
3753 user_name, group_name, ldap_err2string(rc));
3754 }
3755
3756 return(rc);
3757}
3758
3759int contact_remove_email(LDAP *ld, char *bind_path,
3760 LK_ENTRY **linklist_base, int linklist_current)
3761{
3762 LK_ENTRY *gPtr;
3763 int rc;
3764 char *mail_v[] = {NULL, NULL};
3765 LDAPMod *mods[20];
3766 int n;
3767 int i;
3768
3769 mail_v[0] = NULL;
3770
3771 n = 0;
3772 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
3773 ADD_ATTR("mailNickName", mail_v, LDAP_MOD_REPLACE);
3774 ADD_ATTR("proxyAddresses", mail_v, LDAP_MOD_REPLACE);
3775 ADD_ATTR("targetAddress", mail_v, LDAP_MOD_REPLACE);
3776 mods[n] = NULL;
3777
3778 gPtr = (*linklist_base);
3779
3780 while(gPtr) {
3781 rc = ldap_modify_s(ld, gPtr->dn, mods);
3782
3783 if ((rc != LDAP_SUCCESS) && (rc != LDAP_ALREADY_EXISTS))
3784 {
c9ef9269 3785 com_err(whoami, 0, "Unable to modify contact %s in directory : %s",
61a2844b 3786 gPtr->dn, ldap_err2string(rc));
3787 return(rc);
3788 }
3789
3790 gPtr = gPtr->next;
3791 }
3792
3793 for (i = 0; i < n; i++)
3794 free(mods[i]);
3795
3796 return(rc);
3797}
3798
3799int contact_create(LDAP *ld, char *bind_path, char *user, char *group_ou)
3800{
3801 LDAPMod *mods[20];
3802 LK_ENTRY *group_base;
3803 int group_count;
3804 char new_dn[256];
3805 char cn_user_name[256];
3806 char contact_name[256];
3807 char mail_nickname[256];
3808 char proxy_address_internal[256];
3809 char proxy_address_external[256];
3810 char target_address[256];
3811 char internal_contact_name[256];
3812 char filter[128];
3813 char mail[256];
3814 char principal[256];
3815 char mit_address_book[256];
3816 char default_address_book[256];
3817 char contact_address_book[256];
3818 char uid[256];
3819 char *email_v[] = {NULL, NULL};
3820 char *cn_v[] = {NULL, NULL};
3821 char *contact_v[] = {NULL, NULL};
3822 char *uid_v[] = {NULL, NULL};
3823 char *mail_nickname_v[] = {NULL, NULL};
3824 char *proxy_address_internal_v[] = {NULL, NULL};
3825 char *proxy_address_external_v[] = {NULL, NULL};
3826 char *target_address_v[] = {NULL, NULL};
3827 char *mit_address_book_v[] = {NULL, NULL};
3828 char *default_address_book_v[] = {NULL, NULL};
3829 char *contact_address_book_v[] = {NULL, NULL};
3830 char *hide_address_lists_v[] = {NULL, NULL};
3831 char *attr_array[3];
3832 char *objectClass_v[] = {"top", "person",
3833 "organizationalPerson",
3834 "contact", NULL};
3835 char *objectClass_ldap_v[] = {"top", "person", "microsoftComTop",
3836 "inetOrgPerson", "organizationalPerson",
3837 "contact", "mailRecipient", "eduPerson",
3838 NULL};
3839 char *name_v[] = {NULL, NULL};
3840 char *desc_v[] = {NULL, NULL};
3841 char *s;
3842 int n;
3843 int rc;
3844 int i;
3845 char temp[256];
3846 char *c;
3847 char *mail_routing_v[] = {NULL, NULL};
3848 char *principal_v[] = {NULL, NULL};
3849
3850 if (!check_string(user))
3851 {
3852 com_err(whoami, 0, "Unable to process invalid LDAP name %s", user);
3853 return(AD_INVALID_NAME);
3854 }
3855
3856 strcpy(mail, user);
3857 strcpy(contact_name, mail);
3858 strcpy(internal_contact_name, mail);
3859
3860 if((s = strchr(internal_contact_name, '@')) != NULL) {
3861 *s = '?';
3862 }
3863
3864 sprintf(cn_user_name,"CN=%s,%s,%s", escape_string(contact_name), group_ou,
3865 bind_path);
3866
3867 sprintf(target_address, "SMTP:%s", contact_name);
3868 sprintf(proxy_address_external, "SMTP:%s", contact_name);
3869 sprintf(mail_nickname, "%s", internal_contact_name);
3870
3871 cn_v[0] = cn_user_name;
3872 contact_v[0] = contact_name;
3873 uid_v[0] = uid;
3874 name_v[0] = user;
3875 desc_v[0] = "Auto account created by Moira";
3876 email_v[0] = mail;
3877 proxy_address_internal_v[0] = proxy_address_internal;
3878 proxy_address_external_v[0] = proxy_address_external;
3879 mail_nickname_v[0] = mail_nickname;
3880 target_address_v[0] = target_address;
3881 mit_address_book_v[0] = mit_address_book;
3882 default_address_book_v[0] = default_address_book;
3883 contact_address_book_v[0] = contact_address_book;
3884 strcpy(new_dn, cn_user_name);
3885 n = 0;
3886
3887 ADD_ATTR("cn", contact_v, LDAP_MOD_ADD);
3888
3889 if(!ActiveDirectory)
3890 {
3891 if(!strcmp(group_ou, contact_ou))
3892 sprintf(uid, "%s%s", contact_name, "_strings");
3893
3894 if(!strcmp(group_ou, kerberos_ou))
3895 sprintf(uid, "%s%s", contact_name, "_kerberos");
3896
3897 uid_v[0] = uid;
3898
3899 ADD_ATTR("sn", contact_v, LDAP_MOD_ADD);
3900 ADD_ATTR("uid", uid_v, LDAP_MOD_ADD);
3901 }
3902
3903 if(ActiveDirectory)
3904 {
3905 ADD_ATTR("objectClass", objectClass_v, LDAP_MOD_ADD);
3906 }
3907 else
3908 {
3909 ADD_ATTR("objectClass", objectClass_ldap_v, LDAP_MOD_ADD);
3910 }
3911
3912 ADD_ATTR("name", name_v, LDAP_MOD_ADD);
3913 ADD_ATTR("displayName", name_v, LDAP_MOD_ADD);
3914 ADD_ATTR("description", desc_v, LDAP_MOD_ADD);
3915
3916 if (Exchange)
3917 {
7be1cfa9 3918 if((s = strstr(mail, "@mit.edu")) != (char *) NULL)
3919 return(rc);
3920
61a2844b 3921 if (!strcmp(group_ou, contact_ou) && email_isvalid(mail))
3922 {
3923 group_count = 0;
3924 group_base = NULL;
3925
3926 sprintf(filter, "(&(objectClass=user)(cn=%s))", mail);
3927 attr_array[0] = "cn";
3928 attr_array[1] = NULL;
3929
3930 if ((rc = linklist_build(ld, bind_path, filter, attr_array,
3931 &group_base, &group_count,
3932 LDAP_SCOPE_SUBTREE)) != 0)
3933 {
3934 com_err(whoami, 0, "Unable to process contact %s : %s",
3935 user, ldap_err2string(rc));
3936 return(rc);
3937 }
3938
3939 if (group_count)
3940 {
3941 com_err(whoami, 0, "Object already exists with name %s",
3942 user);
3943 return(1);
3944 }
3945
3946 linklist_free(group_base);
3947 group_base = NULL;
3948 group_count = 0;
3949
3950 sprintf(filter, "(&(objectClass=group)(cn=%s))", mail);
3951 attr_array[0] = "cn";
3952 attr_array[1] = NULL;
3953
3954 if ((rc = linklist_build(ld, bind_path, filter, attr_array,
3955 &group_base, &group_count,
3956 LDAP_SCOPE_SUBTREE)) != 0)
3957 {
3958 com_err(whoami, 0, "Unable to process contact %s : %s",
3959 user, ldap_err2string(rc));
3960 return(rc);
3961 }
3962
3963 if (group_count)
3964 {
3965 com_err(whoami, 0, "Object already exists with name %s",
3966 user);
3967 return(1);
3968 }
3969
3970 linklist_free(group_base);
3971 group_count = 0;
3972 group_base = NULL;
c95d6ec1 3973
61a2844b 3974 sprintf(filter, "(&(objectClass=user)(mail=%s))", mail);
3975 attr_array[0] = "cn";
3976 attr_array[1] = NULL;
3977
3978 if ((rc = linklist_build(ld, bind_path, filter, attr_array,
3979 &group_base, &group_count,
3980 LDAP_SCOPE_SUBTREE)) != 0)
3981 {
3982 com_err(whoami, 0, "Unable to process contact %s : %s",
3983 user, ldap_err2string(rc));
3984 return(rc);
3985 }
3986
3987 if (group_count)
3988 {
3989 com_err(whoami, 0, "Object already exists with name %s",
3990 user);
3991 return(1);
3992 }
7be1cfa9 3993
61a2844b 3994 linklist_free(group_base);
3995 group_base = NULL;
3996 group_count = 0;
3997
3998 sprintf(filter, "(&(objectClass=group)(mail=%s))", mail);
3999 attr_array[0] = "cn";
4000 attr_array[1] = NULL;
4001
4002 if ((rc = linklist_build(ld, bind_path, filter, attr_array,
4003 &group_base, &group_count,
4004 LDAP_SCOPE_SUBTREE)) != 0)
4005 {
4006 com_err(whoami, 0, "Unable to process contact %s : %s",
4007 user, ldap_err2string(rc));
4008 return(rc);
4009 }
4010
4011 if (group_count)
4012 {
4013 com_err(whoami, 0, "Object already exists with name %s",
4014 user);
4015 return(1);
4016 }
4017
4018 linklist_free(group_base);
4019 group_base = NULL;
4020 group_count = 0;
c95d6ec1 4021
7be1cfa9 4022 sprintf(filter, "(&(objectClass=user)(proxyAddresses=smtp:%s))", mail);
4023 attr_array[0] = "cn";
4024 attr_array[1] = NULL;
4025
4026 if ((rc = linklist_build(ld, bind_path, filter, attr_array,
4027 &group_base, &group_count,
4028 LDAP_SCOPE_SUBTREE)) != 0)
4029 {
4030 com_err(whoami, 0, "Unable to process contact %s : %s",
4031 user, ldap_err2string(rc));
4032 return(rc);
4033 }
4034
4035 if (group_count)
4036 {
4037 com_err(whoami, 0, "Object already exists with name %s",
4038 user);
4039 return(1);
4040 }
4041
4042 linklist_free(group_base);
4043 group_base = NULL;
4044 group_count = 0;
4045
4046 sprintf(filter, "(&(objectClass=group)(proxyAddresses=smtp:%s))", mail);
4047 attr_array[0] = "cn";
4048 attr_array[1] = NULL;
4049
4050 if ((rc = linklist_build(ld, bind_path, filter, attr_array,
4051 &group_base, &group_count,
4052 LDAP_SCOPE_SUBTREE)) != 0)
4053 {
4054 com_err(whoami, 0, "Unable to process contact %s : %s",
4055 user, ldap_err2string(rc));
4056 return(rc);
4057 }
4058
4059 if (group_count)
4060 {
4061 com_err(whoami, 0, "Object already exists with name %s",
4062 user);
4063 return(1);
4064 }
4065
61a2844b 4066 ADD_ATTR("mail", email_v, LDAP_MOD_ADD);
4067 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_ADD);
4068 ADD_ATTR("proxyAddresses", proxy_address_external_v, LDAP_MOD_ADD);
4069 ADD_ATTR("targetAddress", target_address_v, LDAP_MOD_ADD);
4070
4071 hide_address_lists_v[0] = "TRUE";
4072 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
4073 LDAP_MOD_ADD);
4074 }
4075 }
4076
4077 if(!ActiveDirectory)
4078 {
4079 if((c = strchr(mail, '@')) == NULL)
4080 sprintf(temp, "%s@mit.edu", mail);
4081 else
4082 sprintf(temp, "%s", mail);
4083
4084 mail_routing_v[0] = temp;
4085 email_v[0] = temp;
4086 principal_v[0] = principal;
4087
4088 if(!strcmp(group_ou, contact_ou))
4089 {
4090 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_ADD);
61a2844b 4091 ADD_ATTR("eduPersonPrincipalName", mail_routing_v, LDAP_MOD_ADD);
4092 }
4093 }
4094
4095 mods[n] = NULL;
4096
4097 rc = ldap_add_ext_s(ld, new_dn, mods, NULL, NULL);
4098
4099 for (i = 0; i < n; i++)
4100 free(mods[i]);
4101
4102 if (Exchange)
4103 {
4104 if ((rc != LDAP_SUCCESS) && (rc == LDAP_ALREADY_EXISTS) &&
4105 !strcmp(group_ou, contact_ou) && email_isvalid(mail))
4106 {
4107 n = 0;
4108
4109 ADD_ATTR("mail", email_v, LDAP_MOD_REPLACE);
4110 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_REPLACE);
4111 ADD_ATTR("proxyAddresses", proxy_address_external_v,
4112 LDAP_MOD_REPLACE);
4113 ADD_ATTR("targetAddress", target_address_v, LDAP_MOD_REPLACE);
4114
4115 hide_address_lists_v[0] = "TRUE";
4116 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
4117 LDAP_MOD_REPLACE);
4118
4119 mods[n] = NULL;
4120 rc = ldap_modify_s(ld, new_dn, mods);
4121
4122 if (rc)
4123 {
4124 com_err(whoami, 0, "Unable to update contact %s", mail);
4125 }
4126
4127 for (i = 0; i < n; i++)
4128 free(mods[i]);
4129 }
4130 }
4131
61a2844b 4132 if ((rc != LDAP_SUCCESS) && (rc != LDAP_ALREADY_EXISTS))
4133 {
4134 com_err(whoami, 0, "Unable to create contact %s : %s",
4135 user, ldap_err2string(rc));
4136 return(rc);
4137 }
4138
4139 return(0);
4140}
4141
4142int user_update(LDAP *ldap_handle, char *dn_path, char *user_name,
4143 char *Uid, char *MitId, char *MoiraId, int State,
4144 char *WinHomeDir, char *WinProfileDir, char *first,
4145 char *middle, char *last, char *shell, char *class)
4146{
4147 LDAPMod *mods[20];
4148 LK_ENTRY *group_base;
4149 int group_count;
4150 char distinguished_name[512];
4151 char displayName[256];
c95d6ec1 4152 char address_book[1024];
61a2844b 4153 char *mitMoiraId_v[] = {NULL, NULL};
4154 char *mitMoiraClass_v[] = {NULL, NULL};
4155 char *mitMoiraStatus_v[] = {NULL, NULL};
4156 char *uid_v[] = {NULL, NULL};
4157 char *mitid_v[] = {NULL, NULL};
4158 char *homedir_v[] = {NULL, NULL};
4159 char *winProfile_v[] = {NULL, NULL};
4160 char *drives_v[] = {NULL, NULL};
4161 char *userAccountControl_v[] = {NULL, NULL};
4162 char *alt_recipient_v[] = {NULL, NULL};
4163 char *hide_address_lists_v[] = {NULL, NULL};
4164 char *mail_v[] = {NULL, NULL};
4165 char *gid_v[] = {NULL, NULL};
4166 char *loginshell_v[] = {NULL, NULL};
4167 char *principal_v[] = {NULL, NULL};
c95d6ec1 4168 char *address_book_v[] = {NULL, NULL, NULL, NULL, NULL};
61a2844b 4169 char userAccountControlStr[80];
4170 int n;
4171 int rc;
4172 int i;
4173 int OldUseSFU30;
4174 u_int userAccountControl = UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD |
4175 UF_PASSWD_CANT_CHANGE;
4176 char filter[128];
4177 char *attr_array[3];
4178 char temp[1024];
4179 char mail[256];
c95d6ec1 4180 char filesys_name[256];
61a2844b 4181 char contact_mail[256];
4182 char filter_exp[1024];
4183 char search_path[512];
4184 char TemplateDn[512];
4185 char TemplateSamName[128];
4186 char alt_recipient[256];
4187 char principal[256];
4188 char status[256];
4189 char acBERBuf[N_SD_BER_BYTES];
4190 LDAPControl sControl = {"1.2.840.113556.1.4.801",
4191 { N_SD_BER_BYTES, acBERBuf },
4192 TRUE};
4193 LDAPControl *apsServerControls[] = {&sControl, NULL};
4194 LDAPMessage *psMsg;
4195 LDAP_BERVAL **ppsValues;
4196 ULONG dwInfo;
4197 char *argv[3];
4198 char *homeMDB;
4199 char *homeServerName;
4200 char *save_argv[7];
4201 char search_string[256];
4202 char *p, *q;
4203 char *mail_routing_v[] = {NULL, NULL};
c95d6ec1 4204 char *mail_alternate_v[] = {NULL, NULL};
4205 char *mit_moira_imap_address_v[] = {NULL, NULL};
4206 char *deliver_and_redirect_v[] = {NULL, NULL};
61a2844b 4207 char *c;
4208
4209 dwInfo = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
4210 DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
4211 BEREncodeSecurityBits(dwInfo, acBERBuf);
4212
4213 if (!check_string(user_name))
4214 {
4215 com_err(whoami, 0, "Unable to process invalid LDAP user name %s",
4216 user_name);
4217 return(AD_INVALID_NAME);
4218 }
4219
4220 memset(contact_mail, '\0', sizeof(contact_mail));
c95d6ec1 4221 if(Exchange)
4222 sprintf(contact_mail, "%s@exchange-forwarding.mit.edu", user_name);
4223 else
4224 sprintf(contact_mail, "%s@mit.edu", user_name);
61a2844b 4225 memset(mail, '\0', sizeof(mail));
4226 sprintf(mail, "%s@%s", user_name, lowercase(ldap_domain));
4227 memset(alt_recipient, '\0', sizeof(alt_recipient));
c95d6ec1 4228 sprintf(alt_recipient, "cn=%s@exchange-forwarding.mit.edu,%s,%s", user_name,
4229 contact_ou, dn_path);
61a2844b 4230 sprintf(search_string, "@%s", uppercase(ldap_domain));
c95d6ec1 4231 memset(filesys_name, '\0', sizeof(filesys_name));
4232 sprintf(filesys_name, "%s.po", user_name);
61a2844b 4233
4234 if (Exchange)
4235 {
4236 if(contact_create(ldap_handle, dn_path, contact_mail, contact_ou))
4237 {
4238 com_err(whoami, 0, "Unable to create user contact %s", contact_mail);
4239 }
4240 }
4241
4242 group_count = 0;
4243 group_base = NULL;
4244
4245 memset(displayName, '\0', sizeof(displayName));
4246
4247 if (strlen(MoiraId) != 0)
4248 {
4249 if(ActiveDirectory)
4250 {
4251 sprintf(filter, "(&(objectClass=user)(mitMoiraId=%s))", MoiraId);
4252 }
4253 else
4254 {
4255 sprintf(filter,
4256 "(&(objectClass=mitPerson)(mitMoiraId=%s))", MoiraId);
4257 }
4258
4259 attr_array[0] = "cn";
4260 attr_array[1] = NULL;
4261 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
4262 &group_base, &group_count,
4263 LDAP_SCOPE_SUBTREE)) != 0)
4264 {
4265 com_err(whoami, 0, "Unable to process user %s : %s",
4266 user_name, ldap_err2string(rc));
4267 return(rc);
4268 }
4269 }
4270
4271 if (group_count != 1)
4272 {
4273 linklist_free(group_base);
4274 group_base = NULL;
4275 group_count = 0;
4276 sprintf(filter, "(sAMAccountName=%s)", user_name);
4277 attr_array[0] = "cn";
4278 attr_array[1] = NULL;
4279 sprintf(temp, "%s,%s", user_ou, dn_path);
4280 if ((rc = linklist_build(ldap_handle, temp, filter, attr_array,
4281 &group_base, &group_count,
4282 LDAP_SCOPE_SUBTREE)) != 0)
4283 {
4284 com_err(whoami, 0, "Unable to process user %s : %s",
4285 user_name, ldap_err2string(rc));
4286 return(rc);
4287 }
4288 }
4289
4290 if (group_count != 1)
4291 {
c9ef9269 4292 com_err(whoami, 0, "Unable to find user %s in directory",
61a2844b 4293 user_name);
4294 linklist_free(group_base);
4295 return(AD_NO_USER_FOUND);
4296 }
4297
4298 strcpy(distinguished_name, group_base->dn);
4299
4300 linklist_free(group_base);
4301 group_count = 0;
4302
4303 if(!ActiveDirectory)
4304 {
4305 if (rc = moira_connect())
4306 {
08d53213 4307 critical_alert(whoami, "Ldap incremental",
61a2844b 4308 "Error contacting Moira server : %s",
4309 error_message(rc));
4310 return;
4311 }
4312
c95d6ec1 4313 argv[0] = filesys_name;
4314
4315 if (!(rc = mr_query("get_filesys_by_label", 1, argv, save_query_info,
4316 save_argv)))
4317 {
4318 n = 0;
4319 ADD_ATTR("mitMoiraIMAPAddress", mit_moira_imap_address_v,
4320 LDAP_MOD_REPLACE);
4321 mods[n] = NULL;
4322 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4323
4324 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
4325 rc = LDAP_SUCCESS;
4326
4327 if(rc)
4328 com_err(whoami, 0,
4329 "Unable to set the mitMoiraIMAPAddress for %s : %s",
4330 user_name, ldap_err2string(rc));
4331
4332 sprintf(temp, "%s@%s", user_name, save_argv[FS_MACHINE]);
4333
4334 mit_moira_imap_address_v[0] = temp;
4335
4336 n = 0;
4337 ADD_ATTR("mitMoiraIMAPAddress", mit_moira_imap_address_v,
4338 LDAP_MOD_ADD);
4339 mods[n] = NULL;
4340 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4341
4342 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
4343 rc = LDAP_SUCCESS;
4344
4345 if(rc)
4346 com_err(whoami, 0, "Unable to set the mitMoiraIMAPAddress for "
4347 "%s : %s", user_name, ldap_err2string(rc));
4348 } else if(rc==MR_NO_MATCH) {
4349
4350 n = 0;
4351 ADD_ATTR("mitMoiraIMAPServer", mit_moira_imap_address_v,
4352 LDAP_MOD_REPLACE);
4353 mods[n] = NULL;
4354 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4355
4356 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
4357 rc = LDAP_SUCCESS;
4358
4359 if(rc)
4360 com_err(whoami, 0,
4361 "Unable to set the mitMoiraIMAPAddress for %s : %s",
4362 user_name, ldap_err2string(rc));
4363
4364 }
4365
61a2844b 4366 argv[0] = user_name;
c95d6ec1 4367
61a2844b 4368 if (!(rc = mr_query("get_pobox", 1, argv, save_query_info, save_argv)))
4369 {
4370 n = 0;
4371 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_REPLACE);
4372 mods[n] = NULL;
4373 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4374
4375 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
4376 rc = LDAP_SUCCESS;
4377
4378 if(rc)
4379 com_err(whoami, 0,
4380 "Unable to set the mailRoutingAddress for %s : %s",
4381 user_name, ldap_err2string(rc));
4382
4383 p = strdup(save_argv[3]);
4384
4385 if((c = strchr(p, ',')) != NULL)
4386 {
4387 q = strtok(p, ",");
4388 StringTrim(q);
4389
4390 if ((c = strchr(q, '@')) == NULL)
4391 sprintf(temp, "%s@mit.edu", q);
4392 else
4393 sprintf(temp, "%s", q);
4394
4395 if(email_isvalid(temp) && State != US_DELETED)
4396 {
4397 mail_routing_v[0] = temp;
4398
4399 n = 0;
4400 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_ADD);
4401 mods[n] = NULL;
4402 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4403
4404 if (rc == LDAP_ALREADY_EXISTS ||
4405 rc == LDAP_TYPE_OR_VALUE_EXISTS)
4406 rc = LDAP_SUCCESS;
4407
4408 if(rc)
4409 com_err(whoami, 0,
4410 "Unable to set the mailRoutingAddress for %s : %s",
4411 user_name, ldap_err2string(rc));
4412 }
4413
4414 while((q = strtok(NULL, ",")) != NULL) {
4415 StringTrim(q);
4416
4417 if((c = strchr(q, '@')) == NULL)
4418 sprintf(temp, "%s@mit.edu", q);
4419 else
4420 sprintf(temp, "%s", q);
4421
4422 if(email_isvalid(temp) && State != US_DELETED)
4423 {
4424 mail_routing_v[0] = temp;
4425
4426 n = 0;
4427 ADD_ATTR("mailRoutingAddress", mail_routing_v,
4428 LDAP_MOD_ADD);
4429 mods[n] = NULL;
4430 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4431
4432 if (rc == LDAP_ALREADY_EXISTS ||
4433 rc == LDAP_TYPE_OR_VALUE_EXISTS)
4434 rc = LDAP_SUCCESS;
4435
4436 if(rc)
4437 com_err(whoami, 0,
4438 "Unable to set the mailRoutingAddress for "
4439 "%s : %s",
4440 user_name, ldap_err2string(rc));
4441 }
4442 }
4443 } else {
4444 StringTrim(p);
4445
4446 if((c = strchr(p, '@')) == NULL)
4447 sprintf(temp, "%s@mit.edu", p);
4448 else
4449 sprintf(temp, "%s", p);
4450
4451 if(email_isvalid(temp) && State != US_DELETED)
4452 {
4453 mail_routing_v[0] = temp;
4454
4455 n = 0;
4456 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_ADD);
4457 mods[n] = NULL;
4458 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4459
4460 if (rc == LDAP_ALREADY_EXISTS ||
4461 rc == LDAP_TYPE_OR_VALUE_EXISTS)
4462 rc = LDAP_SUCCESS;
4463
4464 if(rc)
4465 com_err(whoami, 0,
4466 "Unable to set the mailRoutingAddress for %s : %s",
4467 user_name, ldap_err2string(rc));
4468 }
4469 }
5d55a4bc 4470 } else if(rc==MR_NO_MATCH) {
4471
4472 n = 0;
4473 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_REPLACE);
4474 mods[n] = NULL;
4475 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4476
4477 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
4478 rc = LDAP_SUCCESS;
4479
4480 if(rc)
4481 com_err(whoami, 0,
4482 "Unable to set the mailRoutingAddress for %s : %s",
4483 user_name, ldap_err2string(rc));
61a2844b 4484 }
4485 moira_disconnect();
4486 }
4487
4488 if ((strlen(MitId) != 0) && (MitId[0] == '9'))
4489 rc = attribute_update(ldap_handle, distinguished_name, MitId,
4490 "employeeID", user_name);
4491 else
4492 rc = attribute_update(ldap_handle, distinguished_name, "none",
4493 "employeeID", user_name);
4494
4495 if(strlen(first)) {
4496 strcat(displayName, first);
4497 }
4498
4499 if(strlen(middle)) {
4500 if(strlen(first))
4501 strcat(displayName, " ");
4502
4503 strcat(displayName, middle);
4504 }
4505
4506 if(strlen(last)) {
4507 if(strlen(middle) || strlen(first))
4508 strcat(displayName, " ");
4509
4510 strcat(displayName, last);
4511 }
4512
4513 if(strlen(displayName))
4514 rc = attribute_update(ldap_handle, distinguished_name, displayName,
4515 "displayName", user_name);
4516 else
4517 rc = attribute_update(ldap_handle, distinguished_name, user_name,
4518 "displayName", user_name);
4519
4520 if(!ActiveDirectory)
4521 {
4522 if(strlen(displayName))
4523 rc = attribute_update(ldap_handle, distinguished_name, displayName,
4524 "cn", user_name);
4525 else
4526 rc = attribute_update(ldap_handle, distinguished_name, user_name,
4527 "cn", user_name);
4528 }
4529
4530 if(!ActiveDirectory)
4531 {
4532 rc = attribute_update(ldap_handle, distinguished_name, displayName,
4533 "eduPersonNickname", user_name);
4534 }
4535
4536 if(strlen(first))
4537 rc = attribute_update(ldap_handle, distinguished_name, first,
4538 "givenName", user_name);
4539 else
4540 rc = attribute_update(ldap_handle, distinguished_name, "",
4541 "givenName", user_name);
4542
4543 if(strlen(middle) == 1)
4544 rc = attribute_update(ldap_handle, distinguished_name, middle,
4545 "initials", user_name);
4546 else
4547 rc = attribute_update(ldap_handle, distinguished_name, "",
4548 "initials", user_name);
4549
4550 if(strlen(last))
4551 rc = attribute_update(ldap_handle, distinguished_name, last,
4552 "sn", user_name);
4553 else
4554 rc = attribute_update(ldap_handle, distinguished_name, "",
4555 "sn", user_name);
4556
4557 if(ActiveDirectory)
4558 {
4559 rc = attribute_update(ldap_handle, distinguished_name, Uid, "uid",
4560 user_name);
4561 }
4562 else
4563 {
4564 rc = attribute_update(ldap_handle, distinguished_name, user_name, "uid",
4565 user_name);
4566 }
4567
4568 rc = attribute_update(ldap_handle, distinguished_name, MoiraId,
4569 "mitMoiraId", user_name);
4570
4571 n = 0;
4572 uid_v[0] = Uid;
4573
4574 if(ActiveDirectory)
4575 {
4576 if (!UseSFU30)
4577 {
4578 ADD_ATTR("uidNumber", uid_v, LDAP_MOD_REPLACE);
4579 }
4580 else
4581 {
4582 ADD_ATTR("msSFU30UidNumber", uid_v, LDAP_MOD_REPLACE);
4583 }
4584 }
4585 else
4586 {
4587 sprintf(principal, "%s@%s", user_name, PRIMARY_REALM);
4588 sprintf(status, "%d", State);
4589 principal_v[0] = principal;
4590 loginshell_v[0] = shell;
4591 mitMoiraClass_v[0] = class;
4592 mitMoiraStatus_v[0] = status;
4593 gid_v[0] = "101";
4594 ADD_ATTR("uidNumber", uid_v, LDAP_MOD_REPLACE);
4595 ADD_ATTR("gidNumber", gid_v, LDAP_MOD_REPLACE);
4596 ADD_ATTR("loginShell", loginshell_v, LDAP_MOD_REPLACE);
4597 ADD_ATTR("eduPersonPrincipalName", mail_v, LDAP_MOD_REPLACE);
4598 ADD_ATTR("mitMoiraClass", mitMoiraClass_v, LDAP_MOD_REPLACE);
4599 ADD_ATTR("mitMoiraStatus", mitMoiraStatus_v, LDAP_MOD_REPLACE);
4600 }
4601
4602 if ((State != US_NO_PASSWD) && (State != US_REGISTERED))
4603 {
4604 userAccountControl |= UF_ACCOUNTDISABLE;
4605
4606 if (Exchange)
4607 {
4608 hide_address_lists_v[0] = "TRUE";
4609 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
4610 LDAP_MOD_REPLACE);
4611 }
4612 }
4613 else
4614 {
4615 if (Exchange)
4616 {
4617 hide_address_lists_v[0] = NULL;
c95d6ec1 4618 address_book_v[0] = address_book;
61a2844b 4619 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
4620 LDAP_MOD_REPLACE);
c95d6ec1 4621
4622 /*
4623 sprintf(address_book, "%s%s", GLOBAL_ADDRESS_LIST_PREFIX, dn_path);
4624 address_book_v[0] = strdup(address_book);
4625 memset(address_book, '\0', sizeof(address_book));
4626 sprintf(address_book, "%s%s", ADDRESS_LIST_PREFIX, dn_path);
4627 address_book_v[1] = strdup(address_book);
4628 memset(address_book, '\0', sizeof(address_book));
4629 sprintf(address_book, "%s%s", EMAIL_ADDRESS_LIST_PREFIX, dn_path);
4630 address_book_v[2] = strdup(address_book);
4631 memset(address_book, '\0', sizeof(address_book));
4632 sprintf(address_book, "%s%s", ALL_ADDRESS_LIST_PREFIX, dn_path);
4633 address_book_v[3] = strdup(address_book);
4634 memset(address_book, '\0', sizeof(address_book));
4635
4636 ADD_ATTR("showInAddressBook", address_book_v,
4637 LDAP_MOD_REPLACE);
4638 */
61a2844b 4639 }
4640 }
4641
4642 sprintf(userAccountControlStr, "%ld", userAccountControl);
4643 userAccountControl_v[0] = userAccountControlStr;
4644 ADD_ATTR("userAccountControl", userAccountControl_v, LDAP_MOD_REPLACE);
4645
4646 if (Exchange)
4647 {
4648 if (rc = moira_connect())
4649 {
08d53213 4650 critical_alert(whoami, "Ldap incremental",
61a2844b 4651 "Error contacting Moira server : %s",
4652 error_message(rc));
4653 return;
4654 }
4655
4656 argv[0] = user_name;
4657
4658 if (!(rc = mr_query("get_pobox", 1, argv, save_query_info, save_argv)))
4659 {
4660 if(!strcmp(save_argv[1], "EXCHANGE") ||
4661 (strstr(save_argv[3], search_string) != NULL))
4662 {
4663 alt_recipient_v[0] = NULL;
4664 ADD_ATTR("altRecipient", alt_recipient_v, LDAP_MOD_REPLACE);
4665
4666 argv[0] = exchange_acl;
4667 argv[1] = "USER";
4668 argv[2] = user_name;
4669
4670 rc = mr_query("add_member_to_list", 3, argv, NULL, NULL);
4671
4672 if ((rc) && (rc != MR_EXISTS))
4673 {
4674 com_err(whoami, 0, "Unable to add user %s to %s: %s",
4675 user_name, exchange_acl, error_message(rc));
4676 }
c95d6ec1 4677
4678 if(!strcmp(save_argv[1], "SPLIT") ||
4679 !strcmp(save_argv[1], "SMTP")) {
4680
4681 deliver_and_redirect_v[0] = "TRUE";
4682 alt_recipient_v[0] = alt_recipient;
4683 ADD_ATTR("altRecipient", alt_recipient_v, LDAP_MOD_REPLACE);
4684 ADD_ATTR("deliverAndRedirect", deliver_and_redirect_v,
4685 LDAP_MOD_REPLACE);
4686 }
61a2844b 4687 }
4688 else
4689 {
c95d6ec1 4690 deliver_and_redirect_v[0] = "FALSE";
61a2844b 4691 alt_recipient_v[0] = alt_recipient;
4692 ADD_ATTR("altRecipient", alt_recipient_v, LDAP_MOD_REPLACE);
c95d6ec1 4693 ADD_ATTR("deliverAndRedirect", deliver_and_redirect_v,
4694 LDAP_MOD_REPLACE);
61a2844b 4695
4696 argv[0] = exchange_acl;
4697 argv[1] = "USER";
4698 argv[2] = user_name;
4699
4700 rc = mr_query("delete_member_from_list", 3, argv, NULL, NULL);
4701
4702 if ((rc) && (rc != MR_NO_MATCH))
4703 {
4704 com_err(whoami, 0,
4705 "Unable to remove user %s from %s: %s, %d",
4706 user_name, exchange_acl, error_message(rc), rc);
4707 }
4708 }
4709 }
4710 else
4711 {
c95d6ec1 4712 deliver_and_redirect_v[0] = "FALSE";
61a2844b 4713 alt_recipient_v[0] = alt_recipient;
4714 ADD_ATTR("altRecipient", alt_recipient_v, LDAP_MOD_REPLACE);
c95d6ec1 4715 ADD_ATTR("deliverAndRedirect", deliver_and_redirect_v,
4716 LDAP_MOD_REPLACE);
4717
61a2844b 4718 argv[0] = exchange_acl;
4719 argv[1] = "USER";
4720 argv[2] = user_name;
4721
4722 rc = mr_query("delete_member_from_list", 3, argv, NULL, NULL);
4723
4724 if ((rc) && (rc != MR_NO_MATCH))
4725 {
4726 com_err(whoami, 0,
4727 "Unable to remove user %s from %s: %s, %d",
4728 user_name, exchange_acl, error_message(rc), rc);
4729 }
4730 }
4731
4732 moira_disconnect();
4733 }
4734 else
4735 {
4736 mail_v[0] = contact_mail;
4737 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
08ca7a3e 4738
4739 if(!ActiveDirectory)
4740 {
4741 ADD_ATTR("mitMoiraMail", mail_v, LDAP_MOD_REPLACE);
4742 }
61a2844b 4743 }
4744
4745 n = SetHomeDirectory(ldap_handle, user_name, distinguished_name, WinHomeDir,
4746 WinProfileDir, homedir_v, winProfile_v,
4747 drives_v, mods, LDAP_MOD_REPLACE, n);
4748
4749 if(ActiveDirectory)
4750 {
4751 sprintf(filter_exp, "(sAMAccountName=%s)", "UserTemplate.u");
4752 sprintf(search_path, "%s,%s", security_template_ou, dn_path);
4753 attr_array[0] = "sAMAccountName";
4754 attr_array[1] = NULL;
4755 group_count = 0;
4756 group_base = NULL;
4757
4758 if ((rc = linklist_build(ldap_handle, search_path, filter_exp,
4759 attr_array,
4760 &group_base, &group_count,
4761 LDAP_SCOPE_SUBTREE) != 0))
4762 return(1);
4763
4764 if (group_count != 1)
4765 {
4766 com_err(whoami, 0, "Unable to process user security template: %s - "
4767 "security not set", "UserTemplate.u");
4768 return(1);
4769 }
4770
4771 strcpy(TemplateDn, group_base->dn);
4772 strcpy(TemplateSamName, group_base->value);
4773 linklist_free(group_base);
4774 group_base = NULL;
4775 group_count = 0;
4776
4777 rc = ldap_search_ext_s(ldap_handle, search_path, LDAP_SCOPE_SUBTREE,
4778 filter_exp, NULL, 0, apsServerControls, NULL,
4779 NULL, 0, &psMsg);
4780
4781 if ((psMsg = ldap_first_entry(ldap_handle, psMsg)) == NULL)
4782 {
4783 com_err(whoami, 0, "Unable to find user security template: %s - "
4784 "security not set", "UserTemplate.u");
4785 return(1);
4786 }
4787
4788 ppsValues = ldap_get_values_len(ldap_handle, psMsg,
4789 "ntSecurityDescriptor");
4790
4791 if (ppsValues == NULL)
4792 {
4793 com_err(whoami, 0, "Unable to find user security template: %s - "
4794 "security not set", "UserTemplate.u");
4795 return(1);
4796 }
4797
4798 ADD_ATTR("ntSecurityDescriptor", (char **)ppsValues,
4799 LDAP_MOD_REPLACE | LDAP_MOD_BVALUES);
4800 }
4801
4802 mods[n] = NULL;
4803
4804 if ((rc = ldap_modify_s(ldap_handle, distinguished_name,
4805 mods)) != LDAP_SUCCESS)
4806 {
4807 OldUseSFU30 = UseSFU30;
4808 SwitchSFU(mods, &UseSFU30, n);
4809 if (OldUseSFU30 != UseSFU30)
4810 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
4811 if (rc)
4812 {
4813 com_err(whoami, 0, "Unable to modify user data for %s : %s",
4814 user_name, ldap_err2string(rc));
4815 }
4816 }
4817
4818 for (i = 0; i < n; i++)
4819 free(mods[i]);
4820
4821 return(rc);
4822}
4823
4824int user_rename(LDAP *ldap_handle, char *dn_path, char *before_user_name,
4825 char *user_name)
4826{
4827 LDAPMod *mods[20];
4828 char new_dn[256];
4829 char old_dn[256];
4830 char upn[256];
4831 char mail[256];
4832 char contact_mail[256];
4833 char proxy_address[256];
7be1cfa9 4834 char proxy_address_mit[256];
4835 char proxy_address_x500[256];
61a2844b 4836 char query_base_dn[256];
4837 char temp[256];
4838 char *userPrincipalName_v[] = {NULL, NULL};
4839 char *altSecurityIdentities_v[] = {NULL, NULL};
4840 char *name_v[] = {NULL, NULL};
4841 char *samAccountName_v[] = {NULL, NULL};
4842 char *mail_v[] = {NULL, NULL};
4843 char *mail_nickname_v[] = {NULL, NULL};
7be1cfa9 4844 char *proxy_address_v[] = {NULL, NULL, NULL, NULL};
61a2844b 4845 char *query_base_dn_v[] = {NULL, NULL};
4846 char *principal_v[] = {NULL, NULL};
4847 char principal[256];
4848 int n;
4849 int rc;
4850 int i;
4851
4852 if (!check_string(before_user_name))
4853 {
4854 com_err(whoami, 0,
4855 "Unable to process invalid LDAP user name %s", before_user_name);
4856 return(AD_INVALID_NAME);
4857 }
4858
4859 if (!check_string(user_name))
4860 {
4861 com_err(whoami, 0,
4862 "Unable to process invalid LDAP user name %s", user_name);
4863 return(AD_INVALID_NAME);
4864 }
4865
4866 strcpy(user_name, user_name);
4867
4868 if(ActiveDirectory)
4869 sprintf(old_dn, "cn=%s,%s,%s", before_user_name, user_ou, dn_path);
4870 else
4871 sprintf(old_dn, "uid=%s,%s,%s", before_user_name, user_ou, dn_path);
4872
4873 if(ActiveDirectory)
4874 sprintf(new_dn, "cn=%s", user_name);
4875 else
4876 sprintf(new_dn, "uid=%s", user_name);
4877
4878 sprintf(mail, "%s@%s", user_name, lowercase(ldap_domain));
7be1cfa9 4879 if(Exchange)
4880 sprintf(contact_mail, "%s@exchange-forwarding.mit.edu", user_name);
4881 else
4882 sprintf(contact_mail, "%s@mit.edu", user_name);
4883 sprintf(proxy_address, "smtp:%s@%s", user_name, lowercase(ldap_domain));
4884 sprintf(proxy_address_mit, "SMTP:%s@mit.edu", user_name);
4885 sprintf(proxy_address_x500, "%s/cn=%s?mit.edu", X500_PREFIX, user_name);
4886
61a2844b 4887 sprintf(principal, "%s@%s", user_name, PRIMARY_REALM);
4888
4889 if ((rc = ldap_rename_s(ldap_handle, old_dn, new_dn, NULL, TRUE,
4890 NULL, NULL)) != LDAP_SUCCESS)
4891 {
4892 com_err(whoami, 0, "Unable to rename user from %s to %s : %s",
4893 before_user_name, user_name, ldap_err2string(rc));
4894 return(rc);
4895 }
4896
4897 if (Exchange)
4898 {
7be1cfa9 4899 sprintf(temp, "cn=%s@exchange-forwarding.mit.edu,%s,%s", before_user_name,
4900 contact_ou, dn_path);
61a2844b 4901
4902 if(rc = ldap_delete_s(ldap_handle, temp))
4903 {
4904 com_err(whoami, 0, "Unable to delete user contact for %s",
4905 user_name);
4906 }
4907
4908 if(contact_create(ldap_handle, dn_path, contact_mail, contact_ou))
4909 {
4910 com_err(whoami, 0, "Unable to create user contact %s", contact_mail);
4911 }
4912 }
4913
4914 name_v[0] = user_name;
4915 sprintf(upn, "%s@%s", user_name, ldap_domain);
4916 userPrincipalName_v[0] = upn;
4917 principal_v[0] = principal;
4918 sprintf(temp, "Kerberos:%s@%s", user_name, PRIMARY_REALM);
4919 sprintf(query_base_dn, "%s%s", ADDRESS_LIST_PREFIX, dn_path);
4920 altSecurityIdentities_v[0] = temp;
4921 samAccountName_v[0] = user_name;
4922 mail_v[0] = mail;
4923 mail_nickname_v[0] = user_name;
7be1cfa9 4924 proxy_address_v[0] = proxy_address_mit;
4925 proxy_address_v[1] = proxy_address;
61a2844b 4926 query_base_dn_v[0] = query_base_dn;
4927
4928 n = 0;
4929 ADD_ATTR("altSecurityIdentities", altSecurityIdentities_v, LDAP_MOD_REPLACE);
4930 ADD_ATTR("userPrincipalName", userPrincipalName_v, LDAP_MOD_REPLACE);
4931 ADD_ATTR("displayName", name_v, LDAP_MOD_REPLACE);
4932 ADD_ATTR("sAMAccountName", samAccountName_v, LDAP_MOD_REPLACE);
4933
4934 if(!ActiveDirectory)
4935 {
4936 ADD_ATTR("uid", samAccountName_v, LDAP_MOD_REPLACE);
4937 ADD_ATTR("eduPersonPrincipalName", mail_v, LDAP_MOD_REPLACE);
4938 ADD_ATTR("displayName", name_v, LDAP_MOD_REPLACE);
4939 ADD_ATTR("eduPersonNickname", name_v, LDAP_MOD_REPLACE);
4940 }
4941
4942 if (Exchange)
4943 {
4944 ADD_ATTR("msExchQueryBaseDN", query_base_dn_v, LDAP_MOD_REPLACE);
4945 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_REPLACE);
4946 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
7be1cfa9 4947 ADD_ATTR("proxyAddresses", proxy_address_v, LDAP_MOD_REPLACE);
61a2844b 4948 }
4949 else
4950 {
4951 mail_v[0] = contact_mail;
4952 ADD_ATTR("mail", mail_v, LDAP_MOD_REPLACE);
08ca7a3e 4953
4954 if(!ActiveDirectory)
4955 {
4956 ADD_ATTR("mitMoiraMail", mail_v, LDAP_MOD_REPLACE);
4957 }
61a2844b 4958 }
4959
4960 mods[n] = NULL;
4961
4962 if(ActiveDirectory)
4963 sprintf(new_dn, "cn=%s,%s,%s", user_name, user_ou, dn_path);
4964 else
4965 sprintf(new_dn, "uid=%s,%s,%s", user_name, user_ou, dn_path);
4966
4967 if ((rc = ldap_modify_s(ldap_handle, new_dn, mods)) != LDAP_SUCCESS)
4968 {
4969 com_err(whoami, 0,
4970 "Unable to modify user data for %s after renaming : %s",
4971 user_name, ldap_err2string(rc));
4972 }
4973
4974 for (i = 0; i < n; i++)
4975 free(mods[i]);
4976
4977 return(rc);
4978}
4979
4980int user_create(int ac, char **av, void *ptr)
4981{
4982 LDAPMod *mods[20];
4983 char new_dn[256];
4984 char user_name[256];
4985 char sam_name[256];
4986 char upn[256];
4987 char mail[256];
4988 char contact_mail[256];
4989 char proxy_address[256];
4990 char mail_nickname[256];
4991 char query_base_dn[256];
4992 char displayName[256];
c95d6ec1 4993 char address_book[1024];
61a2844b 4994 char alt_recipient[256];
c95d6ec1 4995 char filesys_name[256];
61a2844b 4996 char *cn_v[] = {NULL, NULL};
4997 char *objectClass_v[] = {"top", "person", "organizationalPerson",
4998 "user", NULL};
4999 char *objectClass_ldap_v[] = {"top",
5000 "eduPerson", "posixAccount",
5001 "apple-user", "shadowAccount",
5002 "microsoftComTop", "securityPrincipal",
5003 "inetOrgPerson", "user",
5004 "organizationalPerson", "person",
5005 "mailRecipient", NULL};
5006
5007 char *samAccountName_v[] = {NULL, NULL};
5008 char *altSecurityIdentities_v[] = {NULL, NULL};
5009 char *mitMoiraId_v[] = {NULL, NULL};
5010 char *mitMoiraClass_v[] = {NULL, NULL};
5011 char *mitMoiraStatus_v[] = {NULL, NULL};
5012 char *name_v[] = {NULL, NULL};
5013 char *desc_v[] = {NULL, NULL};
5014 char *userPrincipalName_v[] = {NULL, NULL};
5015 char *userAccountControl_v[] = {NULL, NULL};
5016 char *uid_v[] = {NULL, NULL};
5017 char *gid_v[] = {NULL, NULL};
5018 char *mitid_v[] = {NULL, NULL};
5019 char *homedir_v[] = {NULL, NULL};
5020 char *winProfile_v[] = {NULL, NULL};
5021 char *drives_v[] = {NULL, NULL};
5022 char *mail_v[] = {NULL, NULL};
5023 char *givenName_v[] = {NULL, NULL};
5024 char *sn_v[] = {NULL, NULL};
5025 char *initials_v[] = {NULL, NULL};
5026 char *displayName_v[] = {NULL, NULL};
5027 char *proxy_address_v[] = {NULL, NULL};
5028 char *mail_nickname_v[] = {NULL, NULL};
5029 char *query_base_dn_v[] = {NULL, NULL};
c95d6ec1 5030 char *address_book_v[] = {NULL, NULL, NULL, NULL, NULL};
61a2844b 5031 char *homeMDB_v[] = {NULL, NULL};
5032 char *homeServerName_v[] = {NULL, NULL};
5033 char *mdbUseDefaults_v[] = {NULL, NULL};
5034 char *mailbox_guid_v[] = {NULL, NULL};
5035 char *user_culture_v[] = {NULL, NULL};
5036 char *user_account_control_v[] = {NULL, NULL};
5037 char *msexch_version_v[] = {NULL, NULL};
5038 char *alt_recipient_v[] = {NULL, NULL};
5039 char *hide_address_lists_v[] = {NULL, NULL};
5040 char *principal_v[] = {NULL, NULL};
5041 char *loginshell_v[] = {NULL, NULL};
5042 char userAccountControlStr[80];
5043 char temp[1024];
5044 char principal[256];
5045 char filter_exp[1024];
5046 char search_path[512];
5047 char *attr_array[3];
5048 u_int userAccountControl = UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD |
5049 UF_PASSWD_CANT_CHANGE;
5050 int n;
5051 int rc;
5052 int i;
5053 int OldUseSFU30;
5054 char **call_args;
5055 char WinHomeDir[1024];
5056 char WinProfileDir[1024];
5057 char *homeMDB;
5058 char *homeServerName;
5059 ULONG dwInfo;
5060 char acBERBuf[N_SD_BER_BYTES];
5061 LK_ENTRY *group_base;
5062 int group_count;
5063 char TemplateDn[512];
5064 char TemplateSamName[128];
5065 LDAP_BERVAL **ppsValues;
5066 LDAPControl sControl = {"1.2.840.113556.1.4.801",
5067 { N_SD_BER_BYTES, acBERBuf },
5068 TRUE};
5069 LDAPControl *apsServerControls[] = {&sControl, NULL};
5070 LDAPMessage *psMsg;
5071 char *argv[3];
5072 char *save_argv[7];
5073 char search_string[256];
5074 char *o_v[] = {NULL, NULL};
5075 char *p, *q;
5076 char *mail_routing_v[] = {NULL, NULL};
c95d6ec1 5077 char *mail_alternate_v[] = {NULL, NULL};
5078 char *mit_moira_imap_address_v[] = {NULL, NULL};
5079 char *deliver_and_redirect_v[] = {NULL, NULL};
61a2844b 5080 char *c;
5081
5082 call_args = ptr;
5083
5084 dwInfo = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
5085 DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
5086 BEREncodeSecurityBits(dwInfo, acBERBuf);
5087
5088 if (!check_string(av[U_NAME]))
5089 {
5090 callback_rc = AD_INVALID_NAME;
5091 com_err(whoami, 0, "Unable to process invalid LDAP user name %s",
5092 av[U_NAME]);
5093 return(AD_INVALID_NAME);
5094 }
5095
5096 memset(WinHomeDir, '\0', sizeof(WinHomeDir));
5097 memset(WinProfileDir, '\0', sizeof(WinProfileDir));
5098 memset(displayName, '\0', sizeof(displayName));
5099 memset(query_base_dn, '\0', sizeof(query_base_dn));
c95d6ec1 5100 memset(filesys_name, '\0', sizeof(filesys_name));
61a2844b 5101 strcpy(WinHomeDir, av[U_WINHOMEDIR]);
5102 strcpy(WinProfileDir, av[U_WINPROFILEDIR]);
5103 strcpy(user_name, av[U_NAME]);
5104 sprintf(upn, "%s@%s", user_name, ldap_domain);
5105 sprintf(sam_name, "%s", av[U_NAME]);
c95d6ec1 5106 sprintf(filesys_name, "%s.po", user_name);
61a2844b 5107
5108 if(strlen(av[U_FIRST])) {
5109 strcat(displayName, av[U_FIRST]);
5110 }
5111
5112 if(strlen(av[U_MIDDLE])) {
5113 if(strlen(av[U_FIRST]))
5114 strcat(displayName, " ");
5115
5116 strcat(displayName, av[U_MIDDLE]);
5117 }
5118
5119 if(strlen(av[U_LAST])) {
5120 if(strlen(av[U_FIRST]) || strlen(av[U_MIDDLE]))
5121 strcat(displayName, " ");
5122
5123 strcat(displayName, av[U_LAST]);
5124 }
5125
5126 samAccountName_v[0] = sam_name;
b5fafd96 5127
61a2844b 5128 if ((atoi(av[U_STATE]) != US_NO_PASSWD) &&
5129 (atoi(av[U_STATE]) != US_REGISTERED))
5130 {
5131 userAccountControl |= UF_ACCOUNTDISABLE;
61a2844b 5132 }
5133
5134 sprintf(userAccountControlStr, "%ld", userAccountControl);
5135 userAccountControl_v[0] = userAccountControlStr;
5136 userPrincipalName_v[0] = upn;
5137
5138 if(ActiveDirectory)
5139 cn_v[0] = user_name;
5140 else
5141 cn_v[0] = displayName;
5142
5143 name_v[0] = user_name;
5144 desc_v[0] = "Auto account created by Moira";
5145 mail_v[0] = mail;
5146 givenName_v[0] = av[U_FIRST];
5147
5148 if(ActiveDirectory)
5149 sn_v[0] = av[U_LAST];
5150 else
5151 if(strlen(av[U_LAST]))
5152 sn_v[0] = av[U_LAST];
5153 else
5154 sn_v[0] = av[U_NAME];
5155
5156 displayName_v[0] = displayName;
5157 mail_nickname_v[0] = user_name;
5158 o_v[0] = "Massachusetts Institute of Technology";
5159
5160 sprintf(temp, "Kerberos:%s@%s", user_name, PRIMARY_REALM);
5161 sprintf(principal, "%s@%s", user_name, PRIMARY_REALM);
5162 altSecurityIdentities_v[0] = temp;
5163 principal_v[0] = principal;
5164
5165 if(ActiveDirectory)
5166 sprintf(new_dn, "cn=%s,%s,%s", user_name, user_ou, call_args[1]);
5167 else
5168 sprintf(new_dn, "uid=%s,%s,%s", user_name, user_ou, call_args[1]);
5169
5170 sprintf(mail,"%s@%s", user_name, lowercase(ldap_domain));
c95d6ec1 5171 if(Exchange)
5172 sprintf(contact_mail, "%s@exchange-forwarding.mit.edu", user_name);
5173 else
5174 sprintf(contact_mail, "%s@mit.edu", user_name);
61a2844b 5175 sprintf(query_base_dn, "%s%s", ADDRESS_LIST_PREFIX, call_args[1]);
5176 query_base_dn_v[0] = query_base_dn;
c95d6ec1 5177 sprintf(alt_recipient, "cn=%s@exchange-forwarding.mit.edu,%s,%s", user_name,
5178 contact_ou, call_args[1]);
61a2844b 5179 sprintf(search_string, "@%s", uppercase(ldap_domain));
5180
5181 if (Exchange)
5182 {
5183 if(contact_create((LDAP *)call_args[0], call_args[1], contact_mail,
5184 contact_ou))
5185 {
5186 com_err(whoami, 0, "Unable to create user contact %s",
5187 contact_mail);
5188 }
5189
5190 if(find_homeMDB((LDAP *)call_args[0], call_args[1], &homeMDB,
5191 &homeServerName))
5192 {
5193 com_err(whoami, 0, "Unable to locate homeMB and homeServerName");
5194 return(1);
5195 }
5196
5197 com_err(whoami, 0, "homeMDB:%s", homeMDB);
5198 com_err(whoami, 0, "homeServerName:%s", homeServerName);
5199
5200 homeMDB_v[0] = homeMDB;
5201 homeServerName_v[0] = homeServerName;
5202 }
5203
5204 n = 0;
5205
5206 ADD_ATTR("cn", cn_v, LDAP_MOD_ADD);
5207
5208 if(ActiveDirectory)
5209 {
5210 ADD_ATTR("objectClass", objectClass_v, LDAP_MOD_ADD);
5211 }
5212 else
5213 {
5214 ADD_ATTR("objectClass", objectClass_ldap_v, LDAP_MOD_ADD);
5215 }
5216
5217 ADD_ATTR("sAMAccountName", samAccountName_v, LDAP_MOD_ADD);
5218 ADD_ATTR("userPrincipalName", userPrincipalName_v, LDAP_MOD_ADD);
5219 ADD_ATTR("userAccountControl", userAccountControl_v, LDAP_MOD_ADD);
5220 ADD_ATTR("name", name_v, LDAP_MOD_ADD);
5221 ADD_ATTR("description", desc_v, LDAP_MOD_ADD);
5222
5223 if (Exchange)
5224 {
b5fafd96 5225 if ((atoi(av[U_STATE]) != US_NO_PASSWD) &&
5226 (atoi(av[U_STATE]) != US_REGISTERED))
5227 {
5228 hide_address_lists_v[0] = "TRUE";
5229 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
5230 LDAP_MOD_ADD);
5231 }
5232 else
5233 {
5234 hide_address_lists_v[0] = "FALSE";
5235 ADD_ATTR("msExchHideFromAddressLists", hide_address_lists_v,
5236 LDAP_MOD_ADD);
5237 }
5238
61a2844b 5239 ADD_ATTR("msExchQueryBaseDN", query_base_dn_v, LDAP_MOD_ADD);
5240 ADD_ATTR("mailNickName", mail_nickname_v, LDAP_MOD_ADD);
5241 ADD_ATTR("homeMDB", homeMDB_v, LDAP_MOD_ADD);
5242 mdbUseDefaults_v[0] = "TRUE";
5243 ADD_ATTR("mdbUseDefaults", mdbUseDefaults_v, LDAP_MOD_ADD);
5244 ADD_ATTR("msExchHomeServerName", homeServerName_v, LDAP_MOD_ADD);
5245
5246 argv[0] = user_name;
5247
5248 if (!(rc = mr_query("get_pobox", 1, argv, save_query_info, save_argv)))
5249 {
5250 if(!strcmp(save_argv[1], "EXCHANGE") ||
5251 (strstr(save_argv[3], search_string) != NULL))
5252 {
5253 argv[0] = exchange_acl;
5254 argv[1] = "USER";
5255 argv[2] = user_name;
5256
5257 rc = mr_query("add_member_to_list", 3, argv, NULL, NULL);
5258
5259 if ((rc) && (rc != MR_EXISTS))
5260 {
5261 com_err(whoami, 0, "Unable to add user %s to %s: %s",
5262 user_name, exchange_acl, error_message(rc));
5263 }
c95d6ec1 5264
5265 if(!strcmp(save_argv[1], "SPLIT") ||
5266 !strcmp(save_argv[1], "SMTP")) {
5267
5268 deliver_and_redirect_v[0] = "TRUE";
5269 alt_recipient_v[0] = alt_recipient;
5270
5271 ADD_ATTR("altRecipient", alt_recipient_v, LDAP_MOD_ADD);
5272 ADD_ATTR("deliverAndRedirect", deliver_and_redirect_v,
5273 LDAP_MOD_ADD);
5274 }
5275 }
61a2844b 5276 else
5277 {
5278 alt_recipient_v[0] = alt_recipient;
5279 ADD_ATTR("altRecipient", alt_recipient_v, LDAP_MOD_ADD);
5280 }
5281 }
5282 else
5283 {
5284 alt_recipient_v[0] = alt_recipient;
5285 ADD_ATTR("altRecipient", alt_recipient_v, LDAP_MOD_ADD);
5286
5287 com_err(whoami, 0, "Unable to fetch pobox for %s", user_name);
5288 }
5289 }
5290 else
5291 {
5292 mail_v[0] = contact_mail;
5293 ADD_ATTR("mail", mail_v, LDAP_MOD_ADD);
08ca7a3e 5294
5295 if(!ActiveDirectory)
5296 {
5297 ADD_ATTR("mitMoiraMail", mail_v, LDAP_MOD_ADD);
5298 }
61a2844b 5299 }
5300
5301 if(strlen(av[U_FIRST])) {
5302 ADD_ATTR("givenName", givenName_v, LDAP_MOD_ADD);
5303 }
5304
5305 if(strlen(av[U_LAST]) || strlen(av[U_NAME])) {
5306 ADD_ATTR("sn", sn_v, LDAP_MOD_ADD);
5307 }
5308
5309 if(strlen(av[U_FIRST]) || strlen(av[U_MIDDLE]) || strlen(av[U_LAST])) {
5310 ADD_ATTR("displayName", displayName_v, LDAP_MOD_ADD);
5311
5312 if(!ActiveDirectory)
5313 {
5314 ADD_ATTR("eduPersonNickname", displayName_v, LDAP_MOD_ADD);
5315 }
5316 } else {
5317 ADD_ATTR("displayName", name_v, LDAP_MOD_ADD);
5318
5319 if(!ActiveDirectory)
5320 {
5321 ADD_ATTR("eduPersonNickname", name_v, LDAP_MOD_ADD);
5322 }
5323 }
5324
5325 if (strlen(av[U_MIDDLE]) == 1) {
5326 initials_v[0] = av[U_MIDDLE];
5327 ADD_ATTR("initials", initials_v, LDAP_MOD_ADD);
5328 }
5329
5330 if (strlen(call_args[2]) != 0)
5331 {
5332 mitMoiraId_v[0] = call_args[2];
5333 ADD_ATTR("mitMoiraId", mitMoiraId_v, LDAP_MOD_ADD);
5334 }
5335
5336 ADD_ATTR("altSecurityIdentities", altSecurityIdentities_v, LDAP_MOD_ADD);
5337
5338 if(!ActiveDirectory)
5339 {
5340 loginshell_v[0] = av[U_SHELL];
5341 mitMoiraClass_v[0] = av[U_CLASS];
5342 mitMoiraStatus_v[0] = av[U_STATE];
5343 ADD_ATTR("loginShell", loginshell_v, LDAP_MOD_ADD);
5344 ADD_ATTR("uid", samAccountName_v, LDAP_MOD_ADD);
5345 ADD_ATTR("eduPersonPrincipalName", mail_v, LDAP_MOD_ADD);
5346 ADD_ATTR("o", o_v, LDAP_MOD_ADD);
5347 ADD_ATTR("mitMoiraClass", mitMoiraClass_v, LDAP_MOD_ADD);
5348 ADD_ATTR("mitMoiraStatus", mitMoiraStatus_v, LDAP_MOD_ADD);
5349 }
5350
5351 if (strlen(av[U_UID]) != 0)
5352 {
5353 uid_v[0] = av[U_UID];
5354
5355 if(ActiveDirectory)
5356 {
5357 ADD_ATTR("uid", uid_v, LDAP_MOD_ADD);
5358 }
5359 else
5360 {
5361 gid_v[0] = "101";
5362 ADD_ATTR("uidNumber", uid_v, LDAP_MOD_ADD);
5363 ADD_ATTR("gidNumber", gid_v, LDAP_MOD_ADD);
5364 }
5365
5366 if(ActiveDirectory)
5367 {
5368 if (!UseSFU30)
5369 {
5370 ADD_ATTR("uidNumber", uid_v, LDAP_MOD_ADD);
5371 }
5372 else
5373 {
5374 ADD_ATTR("msSFU30UidNumber", uid_v, LDAP_MOD_ADD);
5375 }
5376 }
5377 }
5378
5379 if ((strlen(av[U_MITID]) != 0) && (av[U_MITID][0] == '9'))
5380 mitid_v[0] = av[U_MITID];
5381 else
5382 mitid_v[0] = "none";
5383
5384 ADD_ATTR("employeeID", mitid_v, LDAP_MOD_ADD);
5385
5386 n = SetHomeDirectory((LDAP *)call_args[0], user_name, new_dn,
5387 WinHomeDir, WinProfileDir, homedir_v, winProfile_v,
5388 drives_v, mods, LDAP_MOD_ADD, n);
5389
5390 if(ActiveDirectory)
5391 {
5392 sprintf(filter_exp, "(sAMAccountName=%s)", "UserTemplate.u");
5393 sprintf(search_path, "%s,%s", security_template_ou, call_args[1]);
5394 attr_array[0] = "sAMAccountName";
5395 attr_array[1] = NULL;
5396 group_count = 0;
5397 group_base = NULL;
5398
5399 if ((rc = linklist_build((LDAP *)call_args[0], search_path, filter_exp,
5400 attr_array, &group_base, &group_count,
5401 LDAP_SCOPE_SUBTREE) != 0))
5402 return(1);
5403
5404 if (group_count != 1)
5405 {
5406 com_err(whoami, 0, "Unable to process user security template: %s - "
5407 "security not set", "UserTemplate.u");
5408 return(1);
5409 }
5410
5411 strcpy(TemplateDn, group_base->dn);
5412 strcpy(TemplateSamName, group_base->value);
5413 linklist_free(group_base);
5414 group_base = NULL;
5415 group_count = 0;
5416
5417 rc = ldap_search_ext_s((LDAP *)call_args[0], search_path,
5418 LDAP_SCOPE_SUBTREE, filter_exp, NULL, 0,
5419 apsServerControls, NULL,
5420 NULL, 0, &psMsg);
5421
5422 if ((psMsg = ldap_first_entry((LDAP *)call_args[0], psMsg)) == NULL)
5423 {
5424 com_err(whoami, 0, "Unable to find user security template: %s - "
5425 "security not set", "UserTemplate.u");
5426 return(1);
5427 }
5428
5429 ppsValues = ldap_get_values_len((LDAP *)call_args[0], psMsg,
5430 "ntSecurityDescriptor");
5431 if (ppsValues == NULL)
5432 {
5433 com_err(whoami, 0, "Unable to find user security template: %s - "
5434 "security not set", "UserTemplate.u");
5435 return(1);
5436 }
5437
5438 ADD_ATTR("ntSecurityDescriptor", (char **)ppsValues,
5439 LDAP_MOD_REPLACE | LDAP_MOD_BVALUES);
5440 }
5441
5442 mods[n] = NULL;
5443
5444 rc = ldap_add_ext_s((LDAP *)call_args[0], new_dn, mods, NULL, NULL);
5445
5446 if ((rc != LDAP_SUCCESS) && (rc != LDAP_ALREADY_EXISTS))
5447 {
5448 OldUseSFU30 = UseSFU30;
5449 SwitchSFU(mods, &UseSFU30, n);
5450 if (OldUseSFU30 != UseSFU30)
5451 rc = ldap_add_ext_s((LDAP *)call_args[0], new_dn, mods, NULL, NULL);
5452 }
5453
5454 for (i = 0; i < n; i++)
5455 free(mods[i]);
5456
5457 if ((rc != LDAP_SUCCESS) && (rc != LDAP_ALREADY_EXISTS))
5458 {
5459 com_err(whoami, 0, "Unable to create user %s : %s",
5460 user_name, ldap_err2string(rc));
5461 callback_rc = rc;
5462 return(rc);
5463 }
5464
5465 if ((rc == LDAP_SUCCESS) && (SetPassword))
5466 {
5467 if ((rc = set_password(sam_name, "", ldap_domain)) != 0)
5468 {
5469 ad_kdc_disconnect();
5470 if (!ad_server_connect(default_server, ldap_domain))
5471 {
5472 com_err(whoami, 0, "Unable to set password for user %s : %s",
5473 user_name,
5474 "cannot get changepw ticket from windows domain");
5475 }
5476 else
5477 {
5478 if ((rc = set_password(sam_name, "", ldap_domain)) != 0)
5479 {
5480 com_err(whoami, 0, "Unable to set password for user %s "
5481 ": %ld", user_name, rc);
5482 }
5483 }
5484 }
5485 }
5486
5487 if(!ActiveDirectory)
5488 {
5489 if (rc = moira_connect())
5490 {
08d53213 5491 critical_alert(whoami, "Ldap incremental",
61a2844b 5492 "Error contacting Moira server : %s",
5493 error_message(rc));
5494 return;
5495 }
5496
c95d6ec1 5497 argv[0] = filesys_name;
5498
5499 if (!(rc = mr_query("get_filesys_by_label", 1, argv, save_query_info,
5500 save_argv)))
5501 {
5502 n = 0;
5503 ADD_ATTR("mitMoiraIMAPAddress", mit_moira_imap_address_v,
5504 LDAP_MOD_REPLACE);
5505 mods[n] = NULL;
5506 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
5507
5508 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
5509 rc = LDAP_SUCCESS;
5510
5511 if(rc)
5512 com_err(whoami, 0,
5513 "Unable to set the mitMoiraIMAPAddress for %s : %s",
5514 user_name, ldap_err2string(rc));
5515
5516 sprintf(temp, "%s@%s", user_name, save_argv[FS_MACHINE]);
5517
5518 mit_moira_imap_address_v[0] = temp;
5519
5520 n = 0;
5521 ADD_ATTR("mitMoiraIMAPAddress", mit_moira_imap_address_v,
5522 LDAP_MOD_ADD);
5523 mods[n] = NULL;
5524 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
5525
5526 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
5527 rc = LDAP_SUCCESS;
5528
5529 if(rc)
5530 com_err(whoami, 0, "Unable to set the mitMoiraIMAPAddress for "
5531 "%s : %s", user_name, ldap_err2string(rc));
5532 } else if(rc==MR_NO_MATCH) {
5533
5534 n = 0;
5535 ADD_ATTR("mitMoiraIMAPAddress", mit_moira_imap_address_v,
5536 LDAP_MOD_REPLACE);
5537 mods[n] = NULL;
5538 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
5539
5540 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
5541 rc = LDAP_SUCCESS;
5542
5543 if(rc)
5544 com_err(whoami, 0,
5545 "Unable to set the mitMoiraIMAPAddress for %s : %s",
5546 user_name, ldap_err2string(rc));
5547
5548 }
5549
61a2844b 5550 argv[0] = user_name;
c95d6ec1 5551
61a2844b 5552 if (!(rc = mr_query("get_pobox", 1, argv, save_query_info, save_argv)))
5553 {
0384092e 5554 n = 0;
5555 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_REPLACE);
5556 mods[n] = NULL;
5557 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
5558
5559 if (rc == LDAP_ALREADY_EXISTS || rc == LDAP_TYPE_OR_VALUE_EXISTS)
5560 rc = LDAP_SUCCESS;
5561
5562 if(rc)
5563 com_err(whoami, 0,
5564 "Unable to set the mailRoutingAddress for %s : %s",
5565 user_name, ldap_err2string(rc));
5566
61a2844b 5567 p = strdup(save_argv[3]);
5568
5569 if((c = strchr(p, ',')) != NULL) {
5570 q = strtok(p, ",");
5571 StringTrim(q);
5572
5573 if ((c = strchr(q, '@')) == NULL)
5574 sprintf(temp, "%s@mit.edu", q);
5575 else
5576 sprintf(temp, "%s", q);
5577
5578 if(email_isvalid(temp) && atoi(av[U_STATE]) != US_DELETED)
5579 {
5580 mail_routing_v[0] = temp;
5581
5582 n = 0;
5583 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_ADD);
5584 mods[n] = NULL;
5585 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
5586
5587 if (rc == LDAP_ALREADY_EXISTS ||
5588 rc == LDAP_TYPE_OR_VALUE_EXISTS)
5589 rc = LDAP_SUCCESS;
5590
5591 if(rc)
5592 com_err(whoami, 0,
5593 "Unable to set the mailRoutingAddress for %s : %s",
5594 user_name, ldap_err2string(rc));
5595 }
5596
5597 while((q = strtok(NULL, ",")) != NULL) {
5598 StringTrim(q);
5599
5600 if((c = strchr(q, '@')) == NULL)
5601 sprintf(temp, "%s@mit.edu", q);
5602 else
5603 sprintf(temp, "%s", q);
5604
5605 if(email_isvalid(temp) && atoi(av[U_STATE]) != US_DELETED)
5606 {
5607 mail_routing_v[0] = temp;
5608
5609 n = 0;
5610 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_ADD);
5611 mods[n] = NULL;
5612 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
5613
5614 if (rc == LDAP_ALREADY_EXISTS ||
5615 rc == LDAP_TYPE_OR_VALUE_EXISTS)
5616 rc = LDAP_SUCCESS;
5617
5618 if(rc)
5619 com_err(whoami, 0,
5620 "Unable to set the mailRoutingAddress for %s : %s",
5621 user_name, ldap_err2string(rc));
5622 }
5623 }
5624 } else {
5625 StringTrim(p);
5626
5627 if((c = strchr(p, '@')) == NULL)
5628 sprintf(temp, "%s@mit.edu", p);
5629 else
5630 sprintf(temp, "%s", p);
5631
5632 if(email_isvalid(temp) && atoi(av[U_STATE]) != US_DELETED)
5633 {
5634 mail_routing_v[0] = temp;
5635
5636 n = 0;
5637 ADD_ATTR("mailRoutingAddress", mail_routing_v, LDAP_MOD_ADD);
5638 mods[n] = NULL;
5639 rc = ldap_modify_s((LDAP *)call_args[0], new_dn, mods);
5640
5641 if (rc == LDAP_ALREADY_EXISTS ||
5642 rc == LDAP_TYPE_OR_VALUE_EXISTS)
5643 rc = LDAP_SUCCESS;
5644
5645 if(rc)
5646 com_err(whoami, 0,
5647 "Unable to set the mailRoutingAddress for %s : %s",
5648 user_name, ldap_err2string(rc));
5649 }
5650 }
5651 }
5652 moira_disconnect();
5653 }
5654
5655 return(0);
5656}
5657
5658int user_change_status(LDAP *ldap_handle, char *dn_path,
5659 char *user_name, char *MoiraId,
5660 int operation)
5661{
5662 char filter[128];
5663 char *attr_array[3];
5664 char temp[256];
5665 char distinguished_name[1024];
5666 char **modvalues;
5667 char *mitMoiraId_v[] = {NULL, NULL};
5668 LDAPMod *mods[20];
5669 LK_ENTRY *group_base;
5670 int group_count;
5671 int rc;
5672 int i;
5673 int n;
5674 ULONG ulongValue;
5675
5676 if (!check_string(user_name))
5677 {
5678 com_err(whoami, 0, "Unable to process invalid LDAP user name %s",
5679 user_name);
5680 return(AD_INVALID_NAME);
5681 }
5682
5683 group_count = 0;
5684 group_base = NULL;
5685
5686 if (strlen(MoiraId) != 0)
5687 {
5688 sprintf(filter, "(&(objectClass=user)(mitMoiraId=%s))", MoiraId);
5689 attr_array[0] = "UserAccountControl";
5690 attr_array[1] = NULL;
5691 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
5692 &group_base, &group_count,
5693 LDAP_SCOPE_SUBTREE)) != 0)
5694 {
5695 com_err(whoami, 0, "Unable to process user %s : %s",
5696 user_name, ldap_err2string(rc));
5697 return(rc);
5698 }
5699 }
5700
5701 if (group_count != 1)
5702 {
5703 linklist_free(group_base);
5704 group_count = 0;
5705 group_base = NULL;
5706 sprintf(filter, "(sAMAccountName=%s)", user_name);
5707 attr_array[0] = "UserAccountControl";
5708 attr_array[1] = NULL;
5709 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
5710 &group_base, &group_count,
5711 LDAP_SCOPE_SUBTREE)) != 0)
5712 {
5713 com_err(whoami, 0, "Unable to process user %s : %s",
5714 user_name, ldap_err2string(rc));
5715 return(rc);
5716 }
5717 }
5718
5719 if (group_count != 1)
5720 {
5721 linklist_free(group_base);
c9ef9269 5722 com_err(whoami, 0, "Unable to find user %s in directory",
61a2844b 5723 user_name);
5724 return(LDAP_NO_SUCH_OBJECT);
5725 }
5726
5727 strcpy(distinguished_name, group_base->dn);
5728 ulongValue = atoi((*group_base).value);
5729
5730 if (operation == MEMBER_DEACTIVATE)
5731 ulongValue |= UF_ACCOUNTDISABLE;
5732 else
5733 ulongValue &= ~UF_ACCOUNTDISABLE;
5734
5735 sprintf(temp, "%ld", ulongValue);
5736
5737 if ((rc = construct_newvalues(group_base, group_count, (*group_base).value,
5738 temp, &modvalues, REPLACE)) == 1)
5739 goto cleanup;
5740
5741 linklist_free(group_base);
5742 group_base = NULL;
5743 group_count = 0;
5744 n = 0;
5745 ADD_ATTR("UserAccountControl", modvalues, LDAP_MOD_REPLACE);
5746
5747 if (strlen(MoiraId) != 0)
5748 {
5749 mitMoiraId_v[0] = MoiraId;
5750 ADD_ATTR("mitMoiraId", mitMoiraId_v, LDAP_MOD_REPLACE);
5751 }
5752
5753 mods[n] = NULL;
5754 rc = ldap_modify_s(ldap_handle, distinguished_name, mods);
5755
5756 for (i = 0; i < n; i++)
5757 free(mods[i]);
5758
5759 free_values(modvalues);
5760
5761 if (rc != LDAP_SUCCESS)
5762 {
5763 com_err(whoami, 0, "Unable to change status of user %s : %s",
5764 user_name, ldap_err2string(rc));
5765 }
5766
5767 cleanup:
5768 return(rc);
5769}
5770
5771int user_delete(LDAP *ldap_handle, char *dn_path,
5772 char *u_name, char *MoiraId)
5773{
5774 char filter[128];
5775 char *attr_array[3];
5776 char distinguished_name[1024];
5777 char user_name[512];
5778 LK_ENTRY *group_base;
5779 int group_count;
5780 int rc;
5781 char temp[256];
5782
5783 if (!check_string(u_name))
5784 return(AD_INVALID_NAME);
5785
5786 strcpy(user_name, u_name);
5787 group_count = 0;
5788 group_base = NULL;
5789
5790 if (strlen(MoiraId) != 0)
5791 {
5792 sprintf(filter, "(&(objectClass=user)(mitMoiraId=%s))", MoiraId);
5793 attr_array[0] = "name";
5794 attr_array[1] = NULL;
5795 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
5796 &group_base, &group_count,
5797 LDAP_SCOPE_SUBTREE)) != 0)
5798 {
5799 com_err(whoami, 0, "Unable to process user %s : %s",
5800 user_name, ldap_err2string(rc));
5801 goto cleanup;
5802 }
5803 }
5804
5805 if (group_count != 1)
5806 {
5807 linklist_free(group_base);
5808 group_count = 0;
5809 group_base = NULL;
5810 sprintf(filter, "(sAMAccountName=%s)", user_name);
5811 attr_array[0] = "name";
5812 attr_array[1] = NULL;
5813 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
5814 &group_base, &group_count,
5815 LDAP_SCOPE_SUBTREE)) != 0)
5816 {
5817 com_err(whoami, 0, "Unable to process user %s : %s",
5818 user_name, ldap_err2string(rc));
5819 goto cleanup;
5820 }
5821 }
5822
5823 if (group_count != 1)
5824 {
61a2844b 5825 goto cleanup;
5826 }
5827
5828 strcpy(distinguished_name, group_base->dn);
5829
5830 if (rc = ldap_delete_s(ldap_handle, distinguished_name))
5831 {
5832 com_err(whoami, 0, "Unable to process user %s : %s",
5833 user_name, ldap_err2string(rc));
5834 }
5835
5836 /* Need to add code to delete mit.edu contact */
7be1cfa9 5837
61a2844b 5838 if (Exchange)
5839 {
7be1cfa9 5840 sprintf(temp, "cn=%s@exchange-forwarding.mit.edu,%s,%s", user_name,
5841 contact_ou, dn_path);
61a2844b 5842
5843 if(rc = ldap_delete_s(ldap_handle, temp))
5844 {
5845 com_err(whoami, 0, "Unable to delete user contact for %s",
5846 user_name);
5847 }
5848 }
5849
5850 cleanup:
5851 linklist_free(group_base);
5852
5853 return(0);
5854}
5855
5856void linklist_free(LK_ENTRY *linklist_base)
5857{
5858 LK_ENTRY *linklist_previous;
5859
5860 while (linklist_base != NULL)
5861 {
5862 if (linklist_base->dn != NULL)
5863 free(linklist_base->dn);
5864
5865 if (linklist_base->attribute != NULL)
5866 free(linklist_base->attribute);
5867
5868 if (linklist_base->value != NULL)
5869 free(linklist_base->value);
5870
5871 if (linklist_base->member != NULL)
5872 free(linklist_base->member);
5873
5874 if (linklist_base->type != NULL)
5875 free(linklist_base->type);
5876
5877 if (linklist_base->list != NULL)
5878 free(linklist_base->list);
5879
5880 linklist_previous = linklist_base;
5881 linklist_base = linklist_previous->next;
5882 free(linklist_previous);
5883 }
5884}
5885
5886void free_values(char **modvalues)
5887{
5888 int i;
5889
5890 i = 0;
5891
5892 if (modvalues != NULL)
5893 {
5894 while (modvalues[i] != NULL)
5895 {
5896 free(modvalues[i]);
5897 modvalues[i] = NULL;
5898 ++i;
5899 }
5900 free(modvalues);
5901 }
5902}
5903
5904static int illegalchars[] = {
5905 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
5906 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
5907 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, /* SPACE - / */
5908 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, /* 0 - ? */
5909 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* @ - O */
5910 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, /* P - _ */
5911 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
5912 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* p - ^? */
5913 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5914 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5915 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5916 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5917 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5918 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5919 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5920 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5921};
5922
5923static int illegalchars_ldap[] = {
5924 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
5925 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
a0407f40 5926 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, /* SPACE - / */
61a2844b 5927 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, /* 0 - ? */
5928 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* @ - O */
5929 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, /* P - _ */
5930 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
5931 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* p - ^? */
5932 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5933 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5934 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5935 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5936 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5937 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5938 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5939 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5940};
5941
5942int check_string(char *s)
5943{
5944 char character;
b6e441c5 5945 char *string;
5946
5947 string = s;
61a2844b 5948
5949 for (; *s; s++)
5950 {
5951 character = *s;
5952
5953 if (isupper(character))
5954 character = tolower(character);
5955
5956 if(ActiveDirectory)
5957 {
5958 if (illegalchars[(unsigned) character])
a0407f40 5959 {
5960 com_err(whoami, 0, "Found illegal char '%c' (%d) in string %s",
b6e441c5 5961 character, (unsigned) character, string);
a0407f40 5962 return 0;
5963 }
61a2844b 5964 }
5965 else
5966 {
5967 if (illegalchars_ldap[(unsigned) character])
a0407f40 5968 {
5969 com_err(whoami, 0, "Found illegal char '%c' (%d) in string %s",
b6e441c5 5970 character, (unsigned) character, string);
a0407f40 5971 return 0;
5972 }
61a2844b 5973 }
5974 }
5975
5976 return(1);
5977}
5978
5979int check_container_name(char *s)
5980{
5981 char character;
5982
5983 for (; *s; s++)
5984 {
5985 character = *s;
5986
5987 if (isupper(character))
5988 character = tolower(character);
5989
5990 if (character == ' ')
5991 continue;
5992
5993 if (illegalchars[(unsigned) character])
5994 return 0;
5995 }
5996
5997 return(1);
5998}
5999
6000int mr_connect_cl(char *server, char *client, int version, int auth)
6001{
6002 int status;
6003 char *motd;
6004 char temp[128];
6005
6006 status = mr_connect(server);
6007
6008 if (status)
6009 {
6010 com_err(whoami, status, "while connecting to Moira");
6011 return status;
6012 }
6013
6014 status = mr_motd(&motd);
6015
6016 if (status)
6017 {
6018 mr_disconnect();
6019 com_err(whoami, status, "while checking server status");
6020 return status;
6021 }
6022
6023 if (motd)
6024 {
6025 sprintf(temp, "The Moira server is currently unavailable: %s", motd);
6026 com_err(whoami, status, temp);
6027 mr_disconnect();
6028 return status;
6029 }
6030
6031 status = mr_version(version);
6032
6033 if (status)
6034 {
6035 if (status == MR_UNKNOWN_PROC)
6036 {
6037 if (version > 2)
6038 status = MR_VERSION_HIGH;
6039 else
6040 status = MR_SUCCESS;
6041 }
6042
6043 if (status == MR_VERSION_HIGH)
6044 {
6045 com_err(whoami, 0, "Warning: This client is running newer code "
6046 "than the server.");
6047 com_err(whoami, 0, "Some operations may not work.");
6048 }
6049 else if (status && status != MR_VERSION_LOW)
6050 {
6051 com_err(whoami, status, "while setting query version number.");
6052 mr_disconnect();
6053 return status;
6054 }
6055 }
6056
6057 if (auth)
6058 {
6059 status = mr_krb5_auth(client);
6060 if (status)
6061 {
6062 com_err(whoami, status, "while authenticating to Moira.");
6063 mr_disconnect();
6064 return status;
6065 }
6066 }
6067
6068 return MR_SUCCESS;
6069}
6070
6071void AfsToWinAfs(char* path, char* winPath)
6072{
6073 char* pathPtr;
6074 char* winPathPtr;
6075 strcpy(winPath, WINAFS);
6076 pathPtr = path + strlen(AFS);
6077 winPathPtr = winPath + strlen(WINAFS);
6078
6079 while (*pathPtr)
6080 {
6081 if (*pathPtr == '/')
6082 *winPathPtr = '\\';
6083 else
6084 *winPathPtr = *pathPtr;
6085
6086 pathPtr++;
6087 winPathPtr++;
6088 }
6089}
6090
6091int GetAceInfo(int ac, char **av, void *ptr)
6092{
6093 char **call_args;
6094 int security_flag;
6095
6096 call_args = ptr;
6097
6098 strcpy(call_args[0], av[L_ACE_TYPE]);
6099 strcpy(call_args[1], av[L_ACE_NAME]);
6100 security_flag = 0;
6101 get_group_membership(call_args[2], call_args[3], &security_flag, av);
6102 return(LDAP_SUCCESS);
6103}
6104
6105int checkADname(LDAP *ldap_handle, char *dn_path, char *Name)
6106{
6107 char filter[128];
6108 char *attr_array[3];
6109 int group_count;
6110 int rc;
6111 LK_ENTRY *group_base;
6112
6113 group_count = 0;
6114 group_base = NULL;
6115
6116 sprintf(filter, "(sAMAccountName=%s)", Name);
6117 attr_array[0] = "sAMAccountName";
6118 attr_array[1] = NULL;
6119
6120 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6121 &group_base, &group_count,
6122 LDAP_SCOPE_SUBTREE)) != 0)
6123 {
6124 com_err(whoami, 0, "Unable to process ACE name %s : %s",
6125 Name, ldap_err2string(rc));
6126 return(1);
6127 }
6128
6129 linklist_free(group_base);
6130 group_base = NULL;
6131
6132 if (group_count == 0)
6133 return(0);
6134
6135 return(1);
6136}
6137
6138#define MAX_ACE 7
6139
6140int ProcessAce(LDAP *ldap_handle, char *dn_path, char *Name, char *Type,
c95d6ec1 6141 int UpdateGroup, int *ProcessGroup, char *maillist,
6142 char *nfsgroup)
61a2844b 6143{
6144 char *av[2];
6145 char GroupName[256];
6146 char *call_args[7];
6147 int rc;
6148 char *AceInfo[4];
6149 char AceType[32];
6150 char AceName[128];
6151 char AceMembership[2];
6152 char AceOu[256];
6153 char temp[128];
6154 char *save_argv[U_END];
6155
6156 if (!SetGroupAce)
6157 {
6158 com_err(whoami, 0, "ProcessAce disabled, skipping");
6159 return(0);
6160 }
6161
6162 strcpy(GroupName, Name);
6163
6164 if (strcasecmp(Type, "LIST"))
6165 return(1);
6166
6167 while (1)
6168 {
6169 av[0] = GroupName;
6170 AceInfo[0] = AceType;
6171 AceInfo[1] = AceName;
6172 AceInfo[2] = AceMembership;
6173 AceInfo[3] = AceOu;
6174 memset(AceType, '\0', sizeof(AceType));
6175 memset(AceName, '\0', sizeof(AceName));
6176 memset(AceMembership, '\0', sizeof(AceMembership));
6177 memset(AceOu, '\0', sizeof(AceOu));
6178 callback_rc = 0;
6179
6180 if (rc = mr_query("get_list_info", 1, av, GetAceInfo, AceInfo))
6181 {
a0407f40 6182 if(rc != MR_NO_MATCH)
a2aa35d9 6183 com_err(whoami, 0, "Unable to get ACE info for list %s : %s",
6184 GroupName, error_message(rc));
6185
61a2844b 6186 return(1);
6187 }
6188
6189 if (callback_rc)
6190 {
6191 com_err(whoami, 0, "Unable to get ACE info for list %s", GroupName);
6192 return(1);
6193 }
6194
6195 if ((strcasecmp(AceType, "USER")) && (strcasecmp(AceType, "LIST")))
6196 return(0);
6197
6198 strcpy(temp, AceName);
6199
6200 if (!strcasecmp(AceType, "LIST"))
6201 sprintf(temp, "%s%s", AceName, group_suffix);
6202
6203 if (!UpdateGroup)
6204 {
6205 if (checkADname(ldap_handle, dn_path, temp))
6206 return(0);
6207
6208 (*ProcessGroup) = 1;
6209 }
6210
6211 if (!strcasecmp(AceInfo[0], "LIST"))
6212 {
6213 if (make_new_group(ldap_handle, dn_path, "", AceName, AceOu,
c95d6ec1 6214 AceMembership, 0, UpdateGroup, maillist,
6215 nfsgroup))
61a2844b 6216 return(1);
33448741 6217
6218 populate_group(ldap_handle, dn_path, AceName, AceOu, AceMembership,
8b76dea3 6219 0, "", 1);
61a2844b 6220 }
6221 else if (!strcasecmp(AceInfo[0], "USER"))
6222 {
6223 av[0] = AceName;
6224 call_args[0] = (char *)ldap_handle;
6225 call_args[1] = dn_path;
6226 call_args[2] = "";
6227 call_args[3] = NULL;
6228 callback_rc = 0;
6229
7c22be37 6230 if(!strcasecmp(AceName, PRODUCTION_PRINCIPAL) ||
6231 !strcasecmp(AceName, TEST_PRINCIPAL))
6232 {
6233 return(1);
6234 }
6235
61a2844b 6236 if (rc = mr_query("get_user_account_by_login", 1, av,
6237 save_query_info, save_argv))
6238 {
6239 com_err(whoami, 0, "Unable to process user ACE %s for group %s.",
6240 AceName, Name);
6241 return(1);
6242 }
6243
6244 if (rc = user_create(U_END, save_argv, call_args))
6245 {
6246 com_err(whoami, 0, "Unable to process user ACE %s for group %s.",
6247 AceName, Name);
6248 return(1);
6249 }
6250
6251 if (callback_rc)
6252 {
6253 com_err(whoami, 0, "Unable to process user Ace %s for group %s",
6254 AceName, Name);
6255 return(1);
6256 }
6257
6258 return(0);
6259 }
6260 else
6261 return(1);
6262
6263 if (!strcasecmp(AceType, "LIST"))
6264 {
6265 if (!strcasecmp(GroupName, AceName))
6266 return(0);
6267 }
6268
6269 strcpy(GroupName, AceName);
6270 }
6271
6272 return(1);
6273}
6274
6275int make_new_group(LDAP *ldap_handle, char *dn_path, char *MoiraId,
6276 char *group_name, char *group_ou, char *group_membership,
c95d6ec1 6277 int group_security_flag, int updateGroup, char *maillist,
6278 char *nfsgroup)
61a2844b 6279{
6280 char *av[3];
6281 char *call_args[8];
6282 int rc;
6283 LK_ENTRY *group_base;
6284 int group_count;
6285 char filter[128];
6286 char *attr_array[3];
6287
6288 av[0] = group_name;
6289 call_args[0] = (char *)ldap_handle;
6290 call_args[1] = dn_path;
6291 call_args[2] = group_name;
6292 call_args[3] = (char *)(MOIRA_USERS | MOIRA_KERBEROS | MOIRA_STRINGS);
6293 call_args[4] = (char *)updateGroup;
6294 call_args[5] = MoiraId;
6295 call_args[6] = "0";
6296 call_args[7] = NULL;
6297 callback_rc = 0;
6298
6299 group_count = 0;
6300 group_base = NULL;
6301
6302 if (rc = mr_query("get_list_info", 1, av, group_create, call_args))
6303 {
6304 moira_disconnect();
6305 com_err(whoami, 0, "Unable to create list %s : %s", group_name,
6306 error_message(rc));
6307 return(rc);
6308 }
6309
6310 if (callback_rc)
6311 {
6312 moira_disconnect();
6313 com_err(whoami, 0, "Unable to create list %s", group_name);
6314 return(callback_rc);
6315 }
6316
6317 return(0);
6318}
6319
6320int populate_group(LDAP *ldap_handle, char *dn_path, char *group_name,
6321 char *group_ou, char *group_membership,
8b76dea3 6322 int group_security_flag, char *MoiraId,
6323 int synchronize)
61a2844b 6324{
6325 char *av[3];
6326 char *call_args[7];
6327 char *pUserOu;
6328 LK_ENTRY *ptr;
6329 int rc;
6330 char member[512];
6331 char *s;
6332 char **members;
6333 int i = 0;
6334 int j = 0;
6335 int n = 0;
6336 char group_dn[512];
6337 LDAPMod *mods[20];
e8332ac3 6338 char *member_v[] = {NULL, NULL};
61a2844b 6339 char *save_argv[U_END];
e8332ac3 6340 char machine_ou[256];
6341 char NewMachineName[1024];
61a2844b 6342
6343 com_err(whoami, 0, "Populating group %s", group_name);
6344 av[0] = group_name;
6345 call_args[0] = (char *)ldap_handle;
6346 call_args[1] = dn_path;
6347 call_args[2] = group_name;
e8332ac3 6348 call_args[3] = (char *)(MOIRA_USERS | MOIRA_KERBEROS | MOIRA_STRINGS |
6349 MOIRA_MACHINE);
61a2844b 6350 call_args[4] = NULL;
6351 member_base = NULL;
8b76dea3 6352 group_members = 0;
61a2844b 6353
21214675 6354 if((max_group_members == -1) && !synchronize) {
6355 com_err(whoami, 0, "Skipping populate group for %s", group_name);
6356 return(0);
6357 }
6358
61a2844b 6359 if (rc = mr_query("get_end_members_of_list", 1, av,
6360 member_list_build, call_args))
6361 {
fe81e80b 6362 if(rc == MR_LIST)
6363 return(0);
6364
61a2844b 6365 com_err(whoami, 0, "Unable to populate list %s : %s",
6366 group_name, error_message(rc));
6367 return(3);
6368 }
6369
8b76dea3 6370 if (member_base != NULL)
6371 {
6372 ptr = member_base;
6373
6374 while(ptr != NULL)
6375 {
6376 if (!strcasecmp(ptr->type, "LIST"))
6377 {
6378 ptr = ptr->next;
6379 continue;
6380 }
6381
6382 if (!strcasecmp(ptr->type, "MACHINE") && !ProcessMachineContainer)
6383 {
6384 ptr = ptr->next;
6385 continue;
6386 }
6387
6388 if(!strcasecmp(ptr->type, "USER"))
6389 {
6390 if(!strcasecmp(ptr->member, PRODUCTION_PRINCIPAL) ||
6391 !strcasecmp(ptr->member, TEST_PRINCIPAL))
6392 {
6393 ptr = ptr->next;
6394 continue;
6395 }
6396 }
6397
6398 ptr = ptr->next;
6399 group_members++;
6400 }
6401 }
6402
6403 if(max_group_members && !synchronize && (group_members > max_group_members))
6404 {
6405 com_err(whoami, 0,
6406 "Group %s membership of %d exceeds maximum %d, skipping",
6407 group_name, group_members, max_group_members);
6408 return(0);
6409 }
6410
61a2844b 6411 members = (char **)malloc(sizeof(char *) * 2);
e8332ac3 6412
61a2844b 6413 if (member_base != NULL)
6414 {
6415 ptr = member_base;
6416
6417 while (ptr != NULL)
6418 {
6419 if (!strcasecmp(ptr->type, "LIST"))
6420 {
6421 ptr = ptr->next;
6422 continue;
6423 }
6424
e8332ac3 6425 if (!strcasecmp(ptr->type, "MACHINE") && !ProcessMachineContainer)
6426 {
6427 ptr = ptr->next;
6428 continue;
6429 }
6430
63d9f3c3 6431 if(!strcasecmp(ptr->type, "USER"))
61a2844b 6432 {
63d9f3c3 6433 if(!strcasecmp(ptr->member, PRODUCTION_PRINCIPAL) ||
6434 !strcasecmp(ptr->member, TEST_PRINCIPAL))
6435 {
6436 ptr = ptr->next;
6437 continue;
6438 }
6439
61a2844b 6440 if ((rc = check_user(ldap_handle, dn_path, ptr->member,
6441 "")) == AD_NO_USER_FOUND)
6442 {
6443 com_err(whoami, 0, "creating user %s", ptr->member);
6444
6445 av[0] = ptr->member;
6446 call_args[0] = (char *)ldap_handle;
6447 call_args[1] = dn_path;
6448 call_args[2] = "";
6449 call_args[3] = NULL;
6450 callback_rc = 0;
6451
6452 if (rc = mr_query("get_user_account_by_login", 1, av,
6453 save_query_info, save_argv))
6454 {
6455 com_err(whoami, 0, "Unable to create user %s "
6456 "while populating group %s.", ptr->member,
6457 group_name);
6458
6459 return(3);
6460 }
6461
6462 if (rc = user_create(U_END, save_argv, call_args))
6463 {
6464 com_err(whoami, 0, "Unable to create user %s "
6465 "while populating group %s.", ptr->member,
6466 group_name);
6467
6468 return(3);
6469 }
6470
6471 if (callback_rc)
6472 {
6473 com_err(whoami, 0, "Unable to create user %s "
6474 "while populating group %s", ptr->member,
6475 group_name);
6476
6477 return(3);
6478 }
6479 }
6480
6481 pUserOu = user_ou;
6482
6483 if(ActiveDirectory)
6484 {
6485 sprintf(member, "cn=%s,%s,%s", ptr->member, pUserOu,
6486 dn_path);
6487 }
6488 else
6489 {
6490 sprintf(member, "uid=%s,%s,%s", ptr->member, pUserOu,
6491 dn_path);
6492 }
61a2844b 6493 }
6494 else if (!strcasecmp(ptr->type, "STRING"))
6495 {
6496 if (contact_create(ldap_handle, dn_path, ptr->member,
6497 contact_ou))
6498 return(3);
6499
6500 pUserOu = contact_ou;
6501 sprintf(member, "cn=%s,%s,%s", escape_string(ptr->member),
6502 pUserOu, dn_path);
6503 }
6504 else if (!strcasecmp(ptr->type, "KERBEROS"))
6505 {
6506 if (contact_create(ldap_handle, dn_path, ptr->member,
6507 kerberos_ou))
6508 return(3);
6509
6510 pUserOu = kerberos_ou;
6511 sprintf(member, "cn=%s,%s,%s", escape_string(ptr->member),
6512 pUserOu, dn_path);
6513 }
e8332ac3 6514 else if (!strcasecmp(ptr->type, "MACHINE"))
6515 {
6516 memset(machine_ou, '\0', sizeof(machine_ou));
6517 memset(NewMachineName, '\0', sizeof(NewMachineName));
6518
6519 if (!get_machine_ou(ldap_handle, dn_path, ptr->member,
6520 machine_ou, NewMachineName))
6521 {
6522 pUserOu = machine_ou;
6523 sprintf(member, "cn=%s,%s,%s", NewMachineName, pUserOu,
6524 dn_path);
6525 }
6526 else
6527 {
6528 ptr = ptr->next;
6529 continue;
6530 }
6531 }
61a2844b 6532
6533 if(i > 1)
6534 members = (char **)realloc(members, ((i + 2) * sizeof(char *)));
6535 members[i++] = strdup(member);
6536
6537 ptr = ptr->next;
6538 }
6539
6540 linklist_free(member_base);
6541 member_base = NULL;
6542 }
6543
6544 members[i] = NULL;
e8332ac3 6545
6546 sprintf(group_dn, "cn=%s,%s,%s", group_name, group_ou, dn_path);
6547
6548 if(GroupPopulateDelete)
6549 {
6550 n = 0;
6551 ADD_ATTR("member", member_v, LDAP_MOD_REPLACE);
6552 mods[n] = NULL;
6553
6554 if ((rc = ldap_modify_s(ldap_handle, group_dn,
6555 mods)) != LDAP_SUCCESS)
6556 {
6557 com_err(whoami, 0,
6558 "Unable to populate group membership for %s: %s",
6559 group_dn, ldap_err2string(rc));
6560 }
61a2844b 6561
e8332ac3 6562 for (i = 0; i < n; i++)
6563 free(mods[i]);
6564 }
6565
61a2844b 6566 n = 0;
6567 ADD_ATTR("member", members, LDAP_MOD_REPLACE);
6568 mods[n] = NULL;
e8332ac3 6569
61a2844b 6570 if ((rc = ldap_modify_s(ldap_handle, group_dn,
6571 mods)) != LDAP_SUCCESS)
6572 {
6573 com_err(whoami, 0,
6574 "Unable to populate group membership for %s: %s",
6575 group_dn, ldap_err2string(rc));
6576 }
6577
6578 for (i = 0; i < n; i++)
6579 free(mods[i]);
e8332ac3 6580
61a2844b 6581 free(members);
6582
6583 return(0);
6584}
6585
6586int process_group(LDAP *ldap_handle, char *dn_path, char *MoiraId,
6587 char *group_name, char *group_ou, char *group_membership,
c95d6ec1 6588 int group_security_flag, int type, char *maillist,
6589 char *nfsgroup)
61a2844b 6590{
6591 char before_desc[512];
6592 char before_name[256];
6593 char before_group_ou[256];
6594 char before_group_membership[2];
6595 char distinguishedName[256];
6596 char ad_distinguishedName[256];
6597 char filter[128];
6598 char *attr_array[3];
6599 int before_security_flag;
6600 int group_count;
6601 int rc;
6602 LK_ENTRY *group_base;
6603 LK_ENTRY *ptr;
6604 char ou_both[512];
6605 char ou_security[512];
6606 char ou_distribution[512];
6607 char ou_neither[512];
6608 char group_dn[512];
6609
6610 memset(ad_distinguishedName, '\0', sizeof(ad_distinguishedName));
6611 sprintf(distinguishedName, "CN=%s,%s,%s", group_name, group_ou, dn_path);
6612
6613 memset(filter, '\0', sizeof(filter));
6614 group_base = NULL;
6615 group_count = 0;
6616
6617 if (rc = ad_get_group(ldap_handle, dn_path, group_name,
6618 "*", MoiraId,
6619 "samAccountName", &group_base,
6620 &group_count, filter))
6621 return(rc);
6622
6623 if (type == CHECK_GROUPS)
6624 {
6625 if (group_count == 1)
6626 {
6627 strcpy(group_dn, group_base->dn);
6628
6629 if (!strcasecmp(group_dn, distinguishedName))
6630 {
6631 linklist_free(group_base);
6632 return(0);
6633 }
6634 }
6635
6636 linklist_free(group_base);
6637
6638 if (group_count == 0)
6639 return(AD_NO_GROUPS_FOUND);
6640
6641 if (group_count == 1)
6642 return(AD_WRONG_GROUP_DN_FOUND);
6643
6644 return(AD_MULTIPLE_GROUPS_FOUND);
6645 }
6646
6647 if (group_count == 0)
6648 {
6649 return(AD_NO_GROUPS_FOUND);
6650 }
6651
6652 if (group_count > 1)
6653 {
6654 ptr = group_base;
6655
6656 strcpy(group_dn, ptr->dn);
6657
6658 while (ptr != NULL)
6659 {
6660 if (!strcasecmp(group_dn, ptr->value))
6661 break;
6662
6663 ptr = ptr->next;
6664 }
6665
6666 if (ptr == NULL)
6667 {
6668 com_err(whoami, 0, "%d groups with moira id = %s", group_count,
6669 MoiraId);
6670 ptr = group_base;
6671
6672 while (ptr != NULL)
6673 {
6674 com_err(whoami, 0, "%s with moira id = %s", ptr->value, MoiraId);
6675 ptr = ptr->next;
6676 }
6677
6678 linklist_free(group_base);
6679 return(AD_MULTIPLE_GROUPS_FOUND);
6680 }
6681
6682 ptr = group_base;
6683
6684 while (ptr != NULL)
6685 {
6686 strcpy(group_dn, ptr->dn);
6687
6688 if (strcasecmp(group_dn, ptr->value))
6689 rc = ldap_delete_s(ldap_handle, ptr->value);
6690
6691 ptr = ptr->next;
6692 }
6693
6694 linklist_free(group_base);
6695 memset(filter, '\0', sizeof(filter));
6696 group_base = NULL;
6697 group_count = 0;
6698
6699 if (rc = ad_get_group(ldap_handle, dn_path, group_name,
6700 "*", MoiraId,
6701 "samAccountName", &group_base,
6702 &group_count, filter))
6703 return(rc);
6704
6705 if (group_count == 0)
6706 return(AD_NO_GROUPS_FOUND);
6707
6708 if (group_count > 1)
6709 return(AD_MULTIPLE_GROUPS_FOUND);
6710 }
6711
6712 strcpy(ad_distinguishedName, group_base->dn);
6713 linklist_free(group_base);
6714 group_base = NULL;
6715 group_count = 0;
6716
6717 attr_array[0] = "sAMAccountName";
6718 attr_array[1] = NULL;
6719
6720 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6721 &group_base, &group_count,
6722 LDAP_SCOPE_SUBTREE)) != 0)
6723 {
6724 com_err(whoami, 0, "Unable to get list info with MoiraId = %s: %s",
6725 MoiraId, ldap_err2string(rc));
6726 return(rc);
6727 }
6728
6729 sprintf(filter, "(sAMAccountName=%s)", group_base->value);
6730
6731 if (!strcasecmp(ad_distinguishedName, distinguishedName))
6732 {
6733 linklist_free(group_base);
6734 group_base = NULL;
6735 group_count = 0;
6736 return(0);
6737 }
6738
6739 linklist_free(group_base);
6740 group_base = NULL;
6741 group_count = 0;
6742 memset(ou_both, '\0', sizeof(ou_both));
6743 memset(ou_security, '\0', sizeof(ou_security));
6744 memset(ou_distribution, '\0', sizeof(ou_distribution));
6745 memset(ou_neither, '\0', sizeof(ou_neither));
6746 memset(before_name, '\0', sizeof(before_name));
6747 memset(before_desc, '\0', sizeof(before_desc));
6748 memset(before_group_membership, '\0', sizeof(before_group_membership));
6749
6750 attr_array[0] = "name";
6751 attr_array[1] = NULL;
6752
6753 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6754 &group_base, &group_count,
6755 LDAP_SCOPE_SUBTREE)) != 0)
6756 {
6757 com_err(whoami, 0, "Unable to get list name with MoiraId = %s: %s",
6758 MoiraId, ldap_err2string(rc));
6759 return(rc);
6760 }
6761
6762 strcpy(before_name, group_base->value);
6763 linklist_free(group_base);
6764 group_base = NULL;
6765 group_count = 0;
6766
6767 attr_array[0] = "description";
6768 attr_array[1] = NULL;
6769
6770 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6771 &group_base, &group_count,
6772 LDAP_SCOPE_SUBTREE)) != 0)
6773 {
6774 com_err(whoami, 0,
6775 "Unable to get list description with MoiraId = %s: %s",
6776 MoiraId, ldap_err2string(rc));
6777 return(rc);
6778 }
6779
6780 if (group_count != 0)
6781 {
6782 strcpy(before_desc, group_base->value);
6783 linklist_free(group_base);
6784 group_base = NULL;
6785 group_count = 0;
6786 }
6787
6788 change_to_lower_case(ad_distinguishedName);
6789 strcpy(ou_both, group_ou_both);
6790 change_to_lower_case(ou_both);
6791 strcpy(ou_security, group_ou_security);
6792 change_to_lower_case(ou_security);
6793 strcpy(ou_distribution, group_ou_distribution);
6794 change_to_lower_case(ou_distribution);
6795 strcpy(ou_neither, group_ou_neither);
6796 change_to_lower_case(ou_neither);
6797
6798 if (strstr(ad_distinguishedName, ou_both))
6799 {
6800 strcpy(before_group_ou, group_ou_both);
6801 before_group_membership[0] = 'B';
6802 before_security_flag = 1;
6803 }
6804 else if (strstr(ad_distinguishedName, ou_security))
6805 {
6806 strcpy(before_group_ou, group_ou_security);
6807 before_group_membership[0] = 'S';
6808 before_security_flag = 1;
6809 }
6810 else if (strstr(ad_distinguishedName, ou_distribution))
6811 {
6812 strcpy(before_group_ou, group_ou_distribution);
6813 before_group_membership[0] = 'D';
6814 before_security_flag = 0;
6815 }
6816 else if (strstr(ad_distinguishedName, ou_neither))
6817 {
6818 strcpy(before_group_ou, group_ou_neither);
6819 before_group_membership[0] = 'N';
6820 before_security_flag = 0;
6821 }
6822 else
6823 return(AD_NO_OU_FOUND);
6824
6825 rc = group_rename(ldap_handle, dn_path, before_name,
6826 before_group_membership,
6827 before_group_ou, before_security_flag, before_desc,
6828 group_name, group_membership, group_ou,
6829 group_security_flag,
c95d6ec1 6830 before_desc, MoiraId, filter, maillist, nfsgroup);
61a2844b 6831
6832 return(rc);
6833}
6834
6835void change_to_lower_case(char *ptr)
6836{
6837 int i;
6838
6839 for (i = 0; i < (int)strlen(ptr); i++)
6840 {
6841 ptr[i] = tolower(ptr[i]);
6842 }
6843}
6844
6845int ad_get_group(LDAP *ldap_handle, char *dn_path,
6846 char *group_name, char *group_membership,
6847 char *MoiraId, char *attribute,
6848 LK_ENTRY **linklist_base, int *linklist_count,
6849 char *rFilter)
6850{
6851 LK_ENTRY *pPtr;
6852 char filter[128];
6853 char *attr_array[3];
6854 char *dn;
6855 int rc;
6856
6857 (*linklist_base) = NULL;
6858 (*linklist_count) = 0;
6859
6860 if (strlen(rFilter) != 0)
6861 {
6862 strcpy(filter, rFilter);
6863 attr_array[0] = attribute;
6864 attr_array[1] = NULL;
6865
6866 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6867 linklist_base, linklist_count,
6868 LDAP_SCOPE_SUBTREE)) != 0)
6869 {
6870 com_err(whoami, 0, "Unable to get list info with MoiraId = %s: %s",
6871 MoiraId, ldap_err2string(rc));
6872 return(rc);
6873 }
6874
6875 if ((*linklist_count) == 1)
6876 {
6877 strcpy(rFilter, filter);
6878 return(0);
6879 }
6880 }
6881
6882 linklist_free((*linklist_base));
6883 (*linklist_base) = NULL;
6884 (*linklist_count) = 0;
6885
6886 if (strlen(MoiraId) != 0)
6887 {
6888 sprintf(filter, "(&(objectClass=group)(mitMoiraId=%s))", MoiraId);
6889
6890 attr_array[0] = attribute;
6891 attr_array[1] = NULL;
6892
6893 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6894 linklist_base, linklist_count,
6895 LDAP_SCOPE_SUBTREE)) != 0)
6896 {
6897 com_err(whoami, 0, "Unable to get list info with MoiraId = %s: %s",
6898 MoiraId, ldap_err2string(rc));
6899 return(rc);
6900 }
6901 }
6902
6903 if ((*linklist_count) > 1)
6904 {
6905 com_err(whoami, 0, "multiple groups with mitMoiraId = %s", MoiraId);
6906 pPtr = (*linklist_base);
6907
6908 while (pPtr)
6909 {
6910 com_err(whoami, 0, "groups %s has mitMoiraId = %s", pPtr->value,
6911 MoiraId);
6912 pPtr = pPtr->next;
6913 }
6914
6915 linklist_free((*linklist_base));
6916 (*linklist_base) = NULL;
6917 (*linklist_count) = 0;
6918 }
6919
6920 if ((*linklist_count) == 1)
6921 {
6922
6923 pPtr = (*linklist_base);
6924 dn = strdup(pPtr->dn);
6925 dn += 3;
6926
6927 if (!memcmp(dn, group_name, strlen(group_name)))
6928 {
6929 strcpy(rFilter, filter);
6930 return(0);
6931 }
6932 }
6933
6934 linklist_free((*linklist_base));
6935 (*linklist_base) = NULL;
6936 (*linklist_count) = 0;
6937 sprintf(filter, "(sAMAccountName=%s%s)", group_name, group_suffix);
6938
6939 attr_array[0] = attribute;
6940 attr_array[1] = NULL;
6941
6942 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6943 linklist_base, linklist_count,
6944 LDAP_SCOPE_SUBTREE)) != 0)
6945 {
6946 com_err(whoami, 0, "Unable to get list info with MoiraId = %s: %s",
6947 MoiraId, ldap_err2string(rc));
6948 return(rc);
6949 }
6950
6951 if ((*linklist_count) == 1)
6952 {
6953 strcpy(rFilter, filter);
6954 return(0);
6955 }
6956
6957 return(0);
6958}
6959
6960int check_user(LDAP *ldap_handle, char *dn_path, char *UserName, char *MoiraId)
6961{
6962 char filter[128];
6963 char *attr_array[3];
6964 char SamAccountName[64];
6965 int group_count;
6966 int rc;
6967 LK_ENTRY *group_base;
6968 LK_ENTRY *gPtr;
6969
6970 group_count = 0;
6971 group_base = NULL;
6972
6973 if (strlen(MoiraId) != 0)
6974 {
6975 sprintf(filter, "(&(objectClass=user)(mitMoiraId=%s))", MoiraId);
6976
6977 attr_array[0] = "sAMAccountName";
6978 attr_array[1] = NULL;
6979 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
6980 &group_base, &group_count,
6981 LDAP_SCOPE_SUBTREE)) != 0)
6982 {
6983 com_err(whoami, 0, "Unable to process user %s : %s",
6984 UserName, ldap_err2string(rc));
6985 return(rc);
6986 }
6987
6988 if (group_count > 1)
6989 {
6990 com_err(whoami, 0, "multiple users exist with MoiraId = %s",
6991 MoiraId);
6992 gPtr = group_base;
6993
6994 while (gPtr)
6995 {
6996 com_err(whoami, 0, "user %s exist with MoiraId = %s",
6997 gPtr->value, MoiraId);
6998 gPtr = gPtr->next;
6999 }
7000 }
7001 }
7002
7003 if (group_count != 1)
7004 {
7005 linklist_free(group_base);
7006 group_count = 0;
7007 group_base = NULL;
7008 sprintf(filter, "(sAMAccountName=%s)", UserName);
7009 attr_array[0] = "sAMAccountName";
7010 attr_array[1] = NULL;
7011
7012 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
7013 &group_base, &group_count,
7014 LDAP_SCOPE_SUBTREE)) != 0)
7015 {
7016 com_err(whoami, 0, "Unable to process user %s : %s",
7017 UserName, ldap_err2string(rc));
7018 return(rc);
7019 }
7020 }
7021
7022 if (group_count != 1)
7023 {
7024 linklist_free(group_base);
7025 return(AD_NO_USER_FOUND);
7026 }
7027
7028 strcpy(SamAccountName, group_base->value);
7029 linklist_free(group_base);
7030 group_count = 0;
7031 rc = 0;
7032
7033 if (strcmp(SamAccountName, UserName))
7034 {
a20c63cf 7035 com_err(whoami, 0,
7036 "User object %s with MoiraId %s has mismatched usernames "
7037 "(LDAP username %s, Moira username %s)", SamAccountName,
7038 MoiraId, SamAccountName, UserName);
61a2844b 7039 }
7040
7041 return(0);
7042}
7043
7044void container_get_dn(char *src, char *dest)
7045{
7046 char *sPtr;
7047 char *array[20];
7048 char name[256];
7049 int n;
7050
7051 memset(array, '\0', 20 * sizeof(array[0]));
7052
7053 if (strlen(src) == 0)
7054 return;
7055
7056 strcpy(name, src);
7057 sPtr = name;
7058 n = 0;
7059 array[n] = name;
7060 ++n;
7061
7062 while (*sPtr)
7063 {
7064 if ((*sPtr) == '/')
7065 {
7066 (*sPtr) = '\0';
7067 ++sPtr;
7068 array[n] = sPtr;
7069 ++n;
7070 }
7071 else
7072 ++sPtr;
7073 }
7074
7075 strcpy(dest, "OU=");
7076
7077 while (n != 0)
7078 {
7079 strcat(dest, array[n-1]);
7080 --n;
7081 if (n > 0)
7082 {
7083 strcat(dest, ",OU=");
7084 }
7085 }
7086
7087 return;
7088}
7089
7090void container_get_name(char *src, char *dest)
7091{
7092 char *sPtr;
7093 char *dPtr;
7094
7095 if (strlen(src) == 0)
7096 return;
7097
7098 sPtr = src;
7099 dPtr = src;
7100
7101 while (*sPtr)
7102 {
7103 if ((*sPtr) == '/')
7104 {
7105 dPtr = sPtr;
7106 ++dPtr;
7107 }
7108 ++sPtr;
7109 }
7110
7111 strcpy(dest, dPtr);
7112 return;
7113}
7114
7115void container_check(LDAP *ldap_handle, char *dn_path, char *name)
7116{
7117 char cName[256];
7118 char *av[7];
7119 int i;
7120 int rc;
7121
7122 strcpy(cName, name);
7123
7124 for (i = 0; i < (int)strlen(cName); i++)
7125 {
7126 if (cName[i] == '/')
7127 {
7128 cName[i] = '\0';
7129 av[CONTAINER_NAME] = cName;
7130 av[CONTAINER_DESC] = "";
7131 av[CONTAINER_LOCATION] = "";
7132 av[CONTAINER_CONTACT] = "";
7133 av[CONTAINER_TYPE] = "";
7134 av[CONTAINER_ID] = "";
7135 av[CONTAINER_ROWID] = "";
7136 rc = container_create(ldap_handle, dn_path, 7, av);
7137
7138 if (rc == LDAP_SUCCESS)
7139 {
7140 com_err(whoami, 0, "container %s created without a mitMoiraId",
7141 cName);
7142 }
7143
7144 cName[i] = '/';
7145 }
7146 }
7147}
7148
7149int container_rename(LDAP *ldap_handle, char *dn_path, int beforec,
7150 char **before, int afterc, char **after)
7151{
7152 char dName[256];
7153 char cName[256];
7154 char new_cn[128];
7155 char new_dn_path[256];
7156 char temp[256];
7157 char distinguishedName[256];
7158 char *pPtr;
7159 int rc;
7160 int i;
7161
7162 memset(cName, '\0', sizeof(cName));
7163 container_get_name(after[CONTAINER_NAME], cName);
7164
7165 if (!check_container_name(cName))
7166 {
7167 com_err(whoami, 0, "Unable to process invalid LDAP container name %s",
7168 cName);
7169 return(AD_INVALID_NAME);
7170 }
7171
7172 memset(distinguishedName, '\0', sizeof(distinguishedName));
7173
7174 if (rc = container_get_distinguishedName(ldap_handle, dn_path,
7175 distinguishedName, beforec, before))
7176 return(rc);
7177
7178 if (strlen(distinguishedName) == 0)
7179 {
7180 rc = container_create(ldap_handle, dn_path, afterc, after);
7181 return(rc);
7182 }
7183
7184 strcpy(temp, after[CONTAINER_NAME]);
7185 pPtr = temp;
7186
7187 for (i = 0; i < (int)strlen(temp); i++)
7188 {
7189 if (temp[i] == '/')
7190 {
7191 pPtr = &temp[i];
7192 }
7193 }
7194
7195 (*pPtr) = '\0';
7196
7197 container_get_dn(temp, dName);
7198
7199 if (strlen(temp) != 0)
7200 sprintf(new_dn_path, "%s,%s", dName, dn_path);
7201 else
7202 sprintf(new_dn_path, "%s", dn_path);
7203
7204 sprintf(new_cn, "OU=%s", cName);
7205
7206 container_check(ldap_handle, dn_path, after[CONTAINER_NAME]);
7207
7208 if ((rc = ldap_rename_s(ldap_handle, distinguishedName, new_cn, new_dn_path,
7209 TRUE, NULL, NULL)) != LDAP_SUCCESS)
7210 {
7211 com_err(whoami, 0, "Unable to rename container from %s to %s : %s",
7212 before[CONTAINER_NAME], after[CONTAINER_NAME],
7213 ldap_err2string(rc));
7214 return(rc);
7215 }
7216
7217 memset(dName, '\0', sizeof(dName));
7218 container_get_dn(after[CONTAINER_NAME], dName);
7219 rc = container_adupdate(ldap_handle, dn_path, dName, "", afterc, after);
7220
7221 return(rc);
7222}
7223
7224int container_delete(LDAP *ldap_handle, char *dn_path, int count, char **av)
7225{
7226 char distinguishedName[256];
7227 int rc;
7228
7229 memset(distinguishedName, '\0', sizeof(distinguishedName));
7230
7231 if (rc = container_get_distinguishedName(ldap_handle, dn_path,
7232 distinguishedName, count, av))
7233 return(rc);
7234
7235 if (strlen(distinguishedName) == 0)
7236 return(0);
7237
7238 if ((rc = ldap_delete_s(ldap_handle, distinguishedName)) != LDAP_SUCCESS)
7239 {
7240 if (rc == LDAP_NOT_ALLOWED_ON_NONLEAF)
7241 container_move_objects(ldap_handle, dn_path, distinguishedName);
7242 else
c9ef9269 7243 com_err(whoami, 0, "Unable to delete container %s from directory : %s",
61a2844b 7244 av[CONTAINER_NAME], ldap_err2string(rc));
7245 }
7246
7247 return(rc);
7248}
7249
7250int container_create(LDAP *ldap_handle, char *dn_path, int count, char **av)
7251{
7252 char *attr_array[3];
7253 LK_ENTRY *group_base;
7254 int group_count;
7255 LDAPMod *mods[20];
7256 char *objectClass_v[] = {"top",
7257 "organizationalUnit",
7258 NULL};
7259
7260 char *ou_v[] = {NULL, NULL};
7261 char *name_v[] = {NULL, NULL};
7262 char *moiraId_v[] = {NULL, NULL};
7263 char *desc_v[] = {NULL, NULL};
7264 char *managedBy_v[] = {NULL, NULL};
7265 char dName[256];
7266 char cName[256];
7267 char managedByDN[256];
7268 char filter[256];
7269 char temp[256];
7270 int n;
7271 int i;
7272 int rc;
7273
7274 memset(filter, '\0', sizeof(filter));
7275 memset(dName, '\0', sizeof(dName));
7276 memset(cName, '\0', sizeof(cName));
7277 memset(managedByDN, '\0', sizeof(managedByDN));
7278 container_get_dn(av[CONTAINER_NAME], dName);
7279 container_get_name(av[CONTAINER_NAME], cName);
7280
7281 if ((strlen(cName) == 0) || (strlen(dName) == 0))
7282 {
7283 com_err(whoami, 0, "Unable to process invalid LDAP container name %s",
7284 cName);
7285 return(AD_INVALID_NAME);
7286 }
7287
7288 if (!check_container_name(cName))
7289 {
7290 com_err(whoami, 0, "Unable to process invalid LDAP container name %s",
7291 cName);
7292 return(AD_INVALID_NAME);
7293 }
7294
7295 n = 0;
7296 ADD_ATTR("objectClass", objectClass_v, LDAP_MOD_ADD);
7297 name_v[0] = cName;
7298 ADD_ATTR("name", name_v, LDAP_MOD_ADD);
7299 ou_v[0] = cName;
7300 ADD_ATTR("ou", ou_v, LDAP_MOD_ADD);
7301
7302 if (strlen(av[CONTAINER_ROWID]) != 0)
7303 {
7304 moiraId_v[0] = av[CONTAINER_ROWID];
7305 ADD_ATTR("mitMoiraId", moiraId_v, LDAP_MOD_ADD);
7306 }
7307
7308 if (strlen(av[CONTAINER_DESC]) != 0)
7309 {
7310 desc_v[0] = av[CONTAINER_DESC];
7311 ADD_ATTR("description", desc_v, LDAP_MOD_ADD);
7312 }
7313
7314 if ((strlen(av[CONTAINER_TYPE]) != 0) && (strlen(av[CONTAINER_ID]) != 0))
7315 {
7316 if (!strcasecmp(av[CONTAINER_TYPE], "KERBEROS"))
7317 {
7318 if (!contact_create(ldap_handle, dn_path, av[CONTAINER_ID],
7319 kerberos_ou))
7320 {
7321 sprintf(managedByDN, "CN=%s,%s,%s", av[CONTAINER_ID],
7322 kerberos_ou, dn_path);
7323 managedBy_v[0] = managedByDN;
7324 ADD_ATTR("managedBy", managedBy_v, LDAP_MOD_ADD);
7325 }
7326 }
7327 else
7328 {
7329 if (!strcasecmp(av[CONTAINER_TYPE], "USER"))
7330 {
7331 sprintf(filter, "(&(cn=%s)(&(objectCategory=person)"
7332 "(objectClass=user)))", av[CONTAINER_ID]);
7333 }
7334
7335 if (!strcasecmp(av[CONTAINER_TYPE], "LIST"))
7336 {
7337 sprintf(filter, "(&(objectClass=group)(cn=%s))",
7338 av[CONTAINER_ID]);
7339 }
7340
7341 if (strlen(filter) != 0)
7342 {
7343 attr_array[0] = "distinguishedName";
7344 attr_array[1] = NULL;
7345 group_count = 0;
7346 group_base = NULL;
7347 if ((rc = linklist_build(ldap_handle, dn_path, filter,
7348 attr_array,
7349 &group_base, &group_count,
7350 LDAP_SCOPE_SUBTREE)) == LDAP_SUCCESS)
7351 {
7352 if (group_count == 1)
7353 {
7354 strcpy(managedByDN, group_base->value);
7355 managedBy_v[0] = managedByDN;
7356 ADD_ATTR("managedBy", managedBy_v, LDAP_MOD_ADD);
7357 }
7358 linklist_free(group_base);
7359 group_base = NULL;
7360 group_count = 0;
7361 }
7362 }
7363 }
7364 }
7365
7366 mods[n] = NULL;
7367
7368 sprintf(temp, "%s,%s", dName, dn_path);
7369 rc = ldap_add_ext_s(ldap_handle, temp, mods, NULL, NULL);
7370
7371 for (i = 0; i < n; i++)
7372 free(mods[i]);
7373
7374 if ((rc != LDAP_SUCCESS) && (rc != LDAP_ALREADY_EXISTS))
7375 {
7376 com_err(whoami, 0, "Unable to create container %s : %s",
7377 cName, ldap_err2string(rc));
7378 return(rc);
7379 }
7380
7381 if (rc == LDAP_ALREADY_EXISTS)
7382 {
7383 if (strlen(av[CONTAINER_ROWID]) != 0)
7384 rc = container_adupdate(ldap_handle, dn_path, dName, "", count, av);
7385 }
7386
7387 return(rc);
7388}
7389
7390int container_update(LDAP *ldap_handle, char *dn_path, int beforec,
7391 char **before, int afterc, char **after)
7392{
7393 char distinguishedName[256];
7394 int rc;
7395
7396 memset(distinguishedName, '\0', sizeof(distinguishedName));
7397
7398 if (rc = container_get_distinguishedName(ldap_handle, dn_path,
7399 distinguishedName, afterc, after))
7400 return(rc);
7401
7402 if (strlen(distinguishedName) == 0)
7403 {
7404 rc = container_create(ldap_handle, dn_path, afterc, after);
7405 return(rc);
7406 }
7407
7408 container_check(ldap_handle, dn_path, after[CONTAINER_NAME]);
7409 rc = container_adupdate(ldap_handle, dn_path, "", distinguishedName, afterc,
7410 after);
7411
7412 return(rc);
7413}
7414
7415int container_get_distinguishedName(LDAP *ldap_handle, char *dn_path,
7416 char *distinguishedName, int count,
7417 char **av)
7418{
7419 char *attr_array[3];
7420 LK_ENTRY *group_base;
7421 int group_count;
7422 char dName[256];
7423 char cName[256];
7424 char filter[512];
7425 int rc;
7426
7427 memset(filter, '\0', sizeof(filter));
7428 memset(dName, '\0', sizeof(dName));
7429 memset(cName, '\0', sizeof(cName));
7430 container_get_dn(av[CONTAINER_NAME], dName);
7431 container_get_name(av[CONTAINER_NAME], cName);
7432
7433 if (strlen(dName) == 0)
7434 {
7435 com_err(whoami, 0, "Unable to process invalid LDAP container name %s",
7436 av[CONTAINER_NAME]);
7437 return(AD_INVALID_NAME);
7438 }
7439
7440 if (!check_container_name(cName))
7441 {
7442 com_err(whoami, 0, "Unable to process invalid LDAP container name %s",
7443 cName);
7444 return(AD_INVALID_NAME);
7445 }
7446
7447 sprintf(filter, "(&(objectClass=organizationalUnit)(mitMoiraId=%s))",
7448 av[CONTAINER_ROWID]);
7449 attr_array[0] = "distinguishedName";
7450 attr_array[1] = NULL;
7451 group_count = 0;
7452 group_base = NULL;
7453
7454 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
7455 &group_base, &group_count,
7456 LDAP_SCOPE_SUBTREE)) == LDAP_SUCCESS)
7457 {
7458 if (group_count == 1)
7459 {
7460 strcpy(distinguishedName, group_base->value);
7461 }
7462
7463 linklist_free(group_base);
7464 group_base = NULL;
7465 group_count = 0;
7466 }
7467
7468 if (strlen(distinguishedName) == 0)
7469 {
7470 sprintf(filter, "(&(objectClass=organizationalUnit)"
7471 "(distinguishedName=%s,%s))", dName, dn_path);
7472 attr_array[0] = "distinguishedName";
7473 attr_array[1] = NULL;
7474 group_count = 0;
7475 group_base = NULL;
7476
7477 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
7478 &group_base, &group_count,
7479 LDAP_SCOPE_SUBTREE)) == LDAP_SUCCESS)
7480 {
7481 if (group_count == 1)
7482 {
7483 strcpy(distinguishedName, group_base->value);
7484 }
7485
7486 linklist_free(group_base);
7487 group_base = NULL;
7488 group_count = 0;
7489 }
7490 }
7491
7492 return(0);
7493}
7494
7495int container_adupdate(LDAP *ldap_handle, char *dn_path, char *dName,
7496 char *distinguishedName, int count, char **av)
7497{
7498 char *attr_array[5];
7499 LK_ENTRY *group_base;
7500 LK_ENTRY *pPtr;
7501 LDAPMod *mods[20];
7502 int group_count;
7503 char filter[512];
7504 char *moiraId_v[] = {NULL, NULL};
7505 char *desc_v[] = {NULL, NULL};
7506 char *managedBy_v[] = {NULL, NULL};
7507 char managedByDN[256];
7508 char moiraId[64];
7509 char desc[256];
7510 char ad_path[512];
7511 int rc;
7512 int i;
7513 int n;
7514
7515
7516 strcpy(ad_path, distinguishedName);
7517
7518 if (strlen(dName) != 0)
7519 sprintf(ad_path, "%s,%s", dName, dn_path);
7520
7521 sprintf(filter, "(&(objectClass=organizationalUnit)(distinguishedName=%s))",
7522 ad_path);
7523
7524 if (strlen(av[CONTAINER_ID]) != 0)
7525 sprintf(filter, "(&(objectClass=organizationalUnit)(mitMoiraId=%s))",
7526 av[CONTAINER_ROWID]);
7527
7528 attr_array[0] = "mitMoiraId";
7529 attr_array[1] = "description";
7530 attr_array[2] = "managedBy";
7531 attr_array[3] = NULL;
7532 group_count = 0;
7533 group_base = NULL;
7534
7535 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
7536 &group_base, &group_count,
7537 LDAP_SCOPE_SUBTREE)) != LDAP_SUCCESS)
7538 {
7539 com_err(whoami, 0, "Unable to retreive container info for %s : %s",
7540 av[CONTAINER_NAME], ldap_err2string(rc));
7541 return(rc);
7542 }
7543
7544 memset(managedByDN, '\0', sizeof(managedByDN));
7545 memset(moiraId, '\0', sizeof(moiraId));
7546 memset(desc, '\0', sizeof(desc));
7547 pPtr = group_base;
7548
7549 while (pPtr)
7550 {
7551 if (!strcasecmp(pPtr->attribute, "description"))
7552 strcpy(desc, pPtr->value);
7553 else if (!strcasecmp(pPtr->attribute, "managedBy"))
7554 strcpy(managedByDN, pPtr->value);
7555 else if (!strcasecmp(pPtr->attribute, "mitMoiraId"))
7556 strcpy(moiraId, pPtr->value);
7557 pPtr = pPtr->next;
7558 }
7559
7560 linklist_free(group_base);
7561 group_base = NULL;
7562 group_count = 0;
7563
7564 n = 0;
7565 if (strlen(av[CONTAINER_ROWID]) != 0)
7566 {
7567 moiraId_v[0] = av[CONTAINER_ROWID];
7568 ADD_ATTR("mitMoiraId", moiraId_v, LDAP_MOD_REPLACE);
7569 }
7570
7571 if (strlen(av[CONTAINER_DESC]) != 0)
7572 {
7573 attribute_update(ldap_handle, ad_path, av[CONTAINER_DESC], "description",
7574 dName);
7575 }
7576 else
7577 {
7578 if (strlen(desc) != 0)
7579 {
7580 attribute_update(ldap_handle, ad_path, "", "description", dName);
7581 }
7582 }
7583
7584 if ((strlen(av[CONTAINER_TYPE]) != 0) && (strlen(av[CONTAINER_ID]) != 0))
7585 {
7586 if (!strcasecmp(av[CONTAINER_TYPE], "KERBEROS"))
7587 {
7588 if (!contact_create(ldap_handle, dn_path, av[CONTAINER_ID],
7589 kerberos_ou))
7590 {
7591 sprintf(managedByDN, "CN=%s,%s,%s", av[CONTAINER_ID],
7592 kerberos_ou, dn_path);
7593 managedBy_v[0] = managedByDN;
7594 ADD_ATTR("managedBy", managedBy_v, LDAP_MOD_REPLACE);
7595 }
7596 else
7597 {
7598 if (strlen(managedByDN) != 0)
7599 {
7600 attribute_update(ldap_handle, ad_path, "", "managedBy",
7601 dName);
7602 }
7603 }
7604 }
7605 else
7606 {
7607 memset(filter, '\0', sizeof(filter));
7608
7609 if (!strcasecmp(av[CONTAINER_TYPE], "USER"))
7610 {
7611 sprintf(filter, "(&(cn=%s)(&(objectCategory=person)"
7612 "(objectClass=user)))", av[CONTAINER_ID]);
7613 }
7614
7615 if (!strcasecmp(av[CONTAINER_TYPE], "LIST"))
7616 {
7617 sprintf(filter, "(&(objectClass=group)(cn=%s))",
7618 av[CONTAINER_ID]);
7619 }
7620
7621 if (strlen(filter) != 0)
7622 {
7623 attr_array[0] = "distinguishedName";
7624 attr_array[1] = NULL;
7625 group_count = 0;
7626 group_base = NULL;
7627 if ((rc = linklist_build(ldap_handle, dn_path, filter,
7628 attr_array, &group_base, &group_count,
7629 LDAP_SCOPE_SUBTREE)) == LDAP_SUCCESS)
7630 {
7631 if (group_count == 1)
7632 {
7633 strcpy(managedByDN, group_base->value);
7634 managedBy_v[0] = managedByDN;
7635 ADD_ATTR("managedBy", managedBy_v, LDAP_MOD_REPLACE);
7636 }
7637 else
7638 {
7639 if (strlen(managedByDN) != 0)
7640 {
7641 attribute_update(ldap_handle, ad_path, "",
7642 "managedBy", dName);
7643 }
7644 }
7645
7646 linklist_free(group_base);
7647 group_base = NULL;
7648 group_count = 0;
7649 }
7650 }
7651 else
7652 {
7653 if (strlen(managedByDN) != 0)
7654 {
7655 attribute_update(ldap_handle, ad_path, "", "managedBy",
7656 dName);
7657 }
7658 }
7659 }
7660 }
7661
7662 mods[n] = NULL;
7663
7664 if (n == 0)
7665 return(LDAP_SUCCESS);
7666
7667 rc = ldap_modify_s(ldap_handle, ad_path, mods);
7668
7669 for (i = 0; i < n; i++)
7670 free(mods[i]);
7671
7672 if (rc != LDAP_SUCCESS)
7673 {
7674 com_err(whoami, 0, "Unable to modify container info for %s : %s",
7675 av[CONTAINER_NAME], ldap_err2string(rc));
7676 return(rc);
7677 }
7678
7679 return(rc);
7680}
7681
7682int container_move_objects(LDAP *ldap_handle, char *dn_path, char *dName)
7683{
7684 char *attr_array[3];
7685 LK_ENTRY *group_base;
7686 LK_ENTRY *pPtr;
7687 int group_count;
7688 char filter[512];
7689 char new_cn[128];
7690 char temp[256];
7691 int rc;
7692 int NumberOfEntries = 10;
7693 int i;
7694 int count;
7695
7696 rc = ldap_set_option(ldap_handle, LDAP_OPT_SIZELIMIT, &NumberOfEntries);
7697
7698 for (i = 0; i < 3; i++)
7699 {
7700 memset(filter, '\0', sizeof(filter));
7701
7702 if (i == 0)
7703 {
7704 strcpy(filter, "(!(|(objectClass=computer)"
7705 "(objectClass=organizationalUnit)))");
7706 attr_array[0] = "cn";
7707 attr_array[1] = NULL;
7708 }
7709 else if (i == 1)
7710 {
7711 strcpy(filter, "(objectClass=computer)");
7712 attr_array[0] = "cn";
7713 attr_array[1] = NULL;
7714 }
7715 else
7716 {
7717 strcpy(filter, "(objectClass=organizationalUnit)");
7718 attr_array[0] = "ou";
7719 attr_array[1] = NULL;
7720 }
7721
7722 while (1)
7723 {
7724 if ((rc = linklist_build(ldap_handle, dName, filter, attr_array,
7725 &group_base, &group_count,
7726 LDAP_SCOPE_SUBTREE)) != LDAP_SUCCESS)
7727 {
7728 break;
7729 }
7730
7731 if (group_count == 0)
7732 break;
7733
7734 pPtr = group_base;
7735
7736 while(pPtr)
7737 {
7738 if (!strcasecmp(pPtr->attribute, "cn"))
7739 {
7740 sprintf(new_cn, "cn=%s", pPtr->value);
7741 if (i == 0)
7742 sprintf(temp, "%s,%s", orphans_other_ou, dn_path);
7743 if (i == 1)
7744 sprintf(temp, "%s,%s", orphans_machines_ou, dn_path);
7745 count = 1;
7746
7747 while (1)
7748 {
7749 rc = ldap_rename_s(ldap_handle, pPtr->dn, new_cn, temp,
7750 TRUE, NULL, NULL);
7751 if (rc == LDAP_ALREADY_EXISTS)
7752 {
7753 sprintf(new_cn, "cn=%s_%d", pPtr->value, count);
7754 ++count;
7755 }
7756 else
7757 break;
7758 }
7759 }
7760 else if (!strcasecmp(pPtr->attribute, "ou"))
7761 {
7762 rc = ldap_delete_s(ldap_handle, pPtr->dn);
7763 }
7764
7765 pPtr = pPtr->next;
7766 }
7767
7768 linklist_free(group_base);
7769 group_base = NULL;
7770 group_count = 0;
7771 }
7772 }
7773
7774 return(0);
7775}
7776
7777int get_machine_ou(LDAP *ldap_handle, char *dn_path, char *member,
7778 char *machine_ou, char *NewMachineName)
7779{
7780 LK_ENTRY *group_base;
7781 int group_count;
7782 int i;
7783 char filter[128];
7784 char *attr_array[3];
7785 char cn[256];
7786 char dn[256];
7787 char temp[256];
7788 char *pPtr;
7789 int rc;
7790
7791 strcpy(NewMachineName, member);
7792 rc = moira_connect();
7793 rc = GetMachineName(NewMachineName);
7794 moira_disconnect();
7795
7796 if (strlen(NewMachineName) == 0)
7797 {
7798 com_err(whoami, 0, "Unable to find alais for machine %s in Moira",
7799 member);
7800 return(1);
7801 }
7802
7803 pPtr = NULL;
7804 pPtr = strchr(NewMachineName, '.');
7805
7806 if (pPtr != NULL)
7807 (*pPtr) = '\0';
7808
7809 group_base = NULL;
7810 group_count = 0;
7811 sprintf(filter, "(sAMAccountName=%s$)", NewMachineName);
7812 attr_array[0] = "cn";
7813 attr_array[1] = NULL;
7814 sprintf(temp, "%s", dn_path);
7815
7816 if ((rc = linklist_build(ldap_handle, temp, filter, attr_array,
7817 &group_base, &group_count,
7818 LDAP_SCOPE_SUBTREE)) != 0)
7819 {
7820 com_err(whoami, 0, "Unable to process machine %s : %s",
7821 member, ldap_err2string(rc));
7822 return(1);
7823 }
7824
7825 if (group_count != 1)
7826 {
61a2844b 7827 return(1);
7828 }
7829
7830 strcpy(dn, group_base->dn);
7831 strcpy(cn, group_base->value);
7832
7833 for (i = 0; i < (int)strlen(dn); i++)
7834 dn[i] = tolower(dn[i]);
7835
7836 for (i = 0; i < (int)strlen(cn); i++)
7837 cn[i] = tolower(cn[i]);
7838
7839 linklist_free(group_base);
7840 pPtr = NULL;
7841 pPtr = strstr(dn, cn);
7842
7843 if (pPtr == NULL)
7844 {
7845 com_err(whoami, 0, "Unable to process machine %s",
7846 member);
7847 return(1);
7848 }
7849
7850 pPtr += strlen(cn) + 1;
7851 strcpy(machine_ou, pPtr);
7852 pPtr = NULL;
7853 pPtr = strstr(machine_ou, "dc=");
7854
7855 if (pPtr == NULL)
7856 {
7857 com_err(whoami, 0, "Unable to process machine %s",
7858 member);
7859 return(1);
7860 }
7861
7862 --pPtr;
7863 (*pPtr) = '\0';
7864
7865 return(0);
7866}
7867
7868int machine_move_to_ou(LDAP *ldap_handle, char * dn_path,
7869 char *MoiraMachineName, char *DestinationOu)
7870{
7871 char NewCn[128];
7872 char OldDn[512];
7873 char MachineName[128];
7874 char filter[128];
7875 char *attr_array[3];
7876 char NewOu[256];
7877 char *cPtr = NULL;
7878 int group_count;
7879 long rc;
7880 LK_ENTRY *group_base;
7881
7882 group_count = 0;
7883 group_base = NULL;
7884
7885 strcpy(MachineName, MoiraMachineName);
7886 rc = GetMachineName(MachineName);
7887
7888 if (strlen(MachineName) == 0)
7889 {
7890 com_err(whoami, 0, "Unable to find alais for machine %s in Moira",
7891 MoiraMachineName);
7892 return(1);
7893 }
7894
7895 cPtr = strchr(MachineName, '.');
7896
7897 if (cPtr != NULL)
7898 (*cPtr) = '\0';
7899
7900 sprintf(filter, "(sAMAccountName=%s$)", MachineName);
7901 attr_array[0] = "sAMAccountName";
7902 attr_array[1] = NULL;
7903
7904 if ((rc = linklist_build(ldap_handle, dn_path, filter, attr_array,
7905 &group_base,
7906 &group_count, LDAP_SCOPE_SUBTREE)) != 0)
7907 {
7908 com_err(whoami, 0, "Unable to process machine %s : %s",
7909 MoiraMachineName, ldap_err2string(rc));
7910 return(1);
7911 }
7912
7913 if (group_count == 1)
7914 strcpy(OldDn, group_base->dn);
7915
7916 linklist_free(group_base);
7917 group_base = NULL;
7918
7919 if (group_count != 1)
7920 {
c9ef9269 7921 com_err(whoami, 0, "Unable to find machine %s in directory: %s",
61a2844b 7922 MoiraMachineName);
7923 return(1);
7924 }
7925
7926 sprintf(NewOu, "%s,%s", DestinationOu, dn_path);
7927 cPtr = strchr(OldDn, ',');
7928
7929 if (cPtr != NULL)
7930 {
7931 ++cPtr;
7932 if (!strcasecmp(cPtr, NewOu))
7933 return(0);
7934 }
7935
7936 sprintf(NewCn, "CN=%s", MachineName);
7937 rc = ldap_rename_s(ldap_handle, OldDn, NewCn, NewOu, TRUE, NULL, NULL);
7938
7939 return(rc);
7940}
7941
7942int machine_check(LDAP *ldap_handle, char *dn_path, char *machine_name)
7943{
7944 char Name[128];
7945 char *pPtr;
7946 int rc;
7947
7948 memset(Name, '\0', sizeof(Name));
7949 strcpy(Name, machine_name);
7950 pPtr = NULL;
7951 pPtr = strchr(Name, '.');
7952
7953 if (pPtr != NULL)
7954 (*pPtr) = '\0';
7955
7956 strcat(Name, "$");
7957 return(!(rc = checkADname(ldap_handle, dn_path, Name)));
7958}
7959
7960int machine_get_moira_container(LDAP *ldap_handle, char *dn_path,
7961 char *machine_name, char *container_name)
7962{
7963 int rc;
7964 char *av[2];
7965 char *call_args[2];
7966
7967 av[0] = machine_name;
7968 call_args[0] = (char *)container_name;
7969 rc = mr_query("get_machine_to_container_map", 1, av,
7970 machine_GetMoiraContainer, call_args);
7971 return(rc);
7972}
7973
7974int machine_GetMoiraContainer(int ac, char **av, void *ptr)
7975{
7976 char **call_args;
7977
7978 call_args = ptr;
7979 strcpy(call_args[0], av[1]);
7980 return(0);
7981}
7982
7983int Moira_container_group_create(char **after)
7984{
7985 long rc;
7986 char GroupName[64];
7987 char *argv[20];
7988
7989 memset(GroupName, '\0', sizeof(GroupName));
7990 rc = Moira_groupname_create(GroupName, after[CONTAINER_NAME],
7991 after[CONTAINER_ROWID]);
7992 if (rc)
7993 return rc;
7994
7995 argv[L_NAME] = GroupName;
7996 argv[L_ACTIVE] = "1";
7997 argv[L_PUBLIC] = "0";
7998 argv[L_HIDDEN] = "0";
7999 argv[L_MAILLIST] = "0";
8000 argv[L_GROUP] = "1";
8001 argv[L_GID] = UNIQUE_GID;
8002 argv[L_NFSGROUP] = "0";
8003 argv[L_MAILMAN] = "0";
8004 argv[L_MAILMAN_SERVER] = "[NONE]";
8005 argv[L_DESC] = "auto created container group";
8006 argv[L_ACE_TYPE] = "USER";
8007 argv[L_MEMACE_TYPE] = "USER";
8008 argv[L_ACE_NAME] = "sms";
8009 argv[L_MEMACE_NAME] = "sms";
8010
8011 if (rc = mr_query("add_list", 15, argv, NULL, NULL))
8012 {
8013 com_err(whoami, 0,
8014 "Unable to create container group %s for container %s: %s",
8015 GroupName, after[CONTAINER_NAME], error_message(rc));
8016 }
8017
8018 Moira_setContainerGroup(after[CONTAINER_NAME], GroupName);
8019 Moira_addGroupToParent(after[CONTAINER_NAME], GroupName);
8020
8021 return(rc);
8022}
8023
8024int Moira_container_group_update(char **before, char **after)
8025{
8026 long rc;
8027 char BeforeGroupName[64];
8028 char AfterGroupName[64];
8029 char *argv[20];
8030
8031 if (!strcasecmp(after[CONTAINER_NAME], before[CONTAINER_NAME]))
8032 return(0);
8033
8034 memset(BeforeGroupName, '\0', sizeof(BeforeGroupName));
8035 Moira_getGroupName(after[CONTAINER_NAME], BeforeGroupName, 0);
8036 if (strlen(BeforeGroupName) == 0)
8037 return(0);
8038
8039 memset(AfterGroupName, '\0', sizeof(AfterGroupName));
8040 rc = Moira_groupname_create(AfterGroupName, after[CONTAINER_NAME],
8041 after[CONTAINER_ROWID]);
8042 if (rc)
8043 return rc;
8044
8045 if (strcasecmp(BeforeGroupName, AfterGroupName))
8046 {
8047 argv[L_NAME] = BeforeGroupName;
8048 argv[L_NAME + 1] = AfterGroupName;
8049 argv[L_ACTIVE + 1] = "1";
8050 argv[L_PUBLIC + 1] = "0";
8051 argv[L_HIDDEN + 1] = "0";
8052 argv[L_MAILLIST + 1] = "0";
8053 argv[L_GROUP + 1] = "1";
8054 argv[L_GID + 1] = UNIQUE_GID;
8055 argv[L_NFSGROUP + 1] = "0";
8056 argv[L_MAILMAN + 1] = "0";
8057 argv[L_MAILMAN_SERVER + 1] = "[NONE]";
8058 argv[L_DESC + 1] = "auto created container group";
8059 argv[L_ACE_TYPE + 1] = "USER";
8060 argv[L_MEMACE_TYPE + 1] = "USER";
8061 argv[L_ACE_NAME + 1] = "sms";
8062 argv[L_MEMACE_NAME + 1] = "sms";
8063
8064 if (rc = mr_query("update_list", 16, argv, NULL, NULL))
8065 {
8066 com_err(whoami, 0,
8067 "Unable to rename container group from %s to %s: %s",
8068 BeforeGroupName, AfterGroupName, error_message(rc));
8069 }
8070 }
8071
8072 return(rc);
8073}
8074
8075int Moira_container_group_delete(char **before)
8076{
8077 long rc = 0;
8078 char *argv[13];
8079 char GroupName[64];
8080 char ParentGroupName[64];
8081
8082 memset(ParentGroupName, '\0', sizeof(ParentGroupName));
8083 Moira_getGroupName(before[CONTAINER_NAME], ParentGroupName, 1);
8084
8085 memset(GroupName, '\0', sizeof(GroupName));
8086
8087 if (strcmp(before[CONTAINER_GROUP_NAME], "[none]"))
8088 strcpy(GroupName, before[CONTAINER_GROUP_NAME]);
8089
8090 if ((strlen(ParentGroupName) != 0) && (strlen(GroupName) != 0))
8091 {
8092 argv[0] = ParentGroupName;
8093 argv[1] = "LIST";
8094 argv[2] = GroupName;
8095
8096 if (rc = mr_query("delete_member_from_list", 3, argv, NULL, NULL))
8097 {
8098 com_err(whoami, 0,
8099 "Unable to delete container group %s from list: %s",
8100 GroupName, ParentGroupName, error_message(rc));
8101 }
8102 }
8103
8104 if (strlen(GroupName) != 0)
8105 {
8106 argv[0] = GroupName;
8107
8108 if (rc = mr_query("delete_list", 1, argv, NULL, NULL))
8109 {
8110 com_err(whoami, 0, "Unable to delete container group %s : %s",
8111 GroupName, error_message(rc));
8112 }
8113 }
8114
8115 return(rc);
8116}
8117
8118int Moira_groupname_create(char *GroupName, char *ContainerName,
8119 char *ContainerRowID)
8120{
8121 char *ptr;
8122 char *ptr1;
8123 char temp[64];
8124 char newGroupName[64];
8125 char tempGroupName[64];
8126 char tempgname[64];
8127 char *argv[1];
8128 int i;
8129 long rc;
8130
8131 strcpy(temp, ContainerName);
8132
8133 ptr1 = strrchr(temp, '/');
8134
8135 if (ptr1 != NULL)
8136 {
8137 *ptr1 = '\0';
8138 ptr = ++ptr1;
8139 ptr1 = strrchr(temp, '/');
8140
8141 if (ptr1 != NULL)
8142 {
8143 sprintf(tempgname, "%s-%s", ++ptr1, ptr);
8144 }
8145 else
8146 strcpy(tempgname, ptr);
8147 }
8148 else
8149 strcpy(tempgname, temp);
8150
8151 if (strlen(tempgname) > 25)
8152 tempgname[25] ='\0';
8153
8154 sprintf(newGroupName, "cnt-%s", tempgname);
8155
8156 /* change everything to lower case */
8157 ptr = newGroupName;
8158
8159 while (*ptr)
8160 {
8161 if (isupper(*ptr))
8162 *ptr = tolower(*ptr);
8163
8164 if (*ptr == ' ')
8165 *ptr = '-';
8166
8167 ptr++;
8168 }
8169
8170 strcpy(tempGroupName, newGroupName);
8171 i = (int)'0';
8172
8173 /* append 0-9 then a-z if a duplicate is found */
8174 while(1)
8175 {
8176 argv[0] = newGroupName;
8177
8178 if (rc = mr_query("get_list_info", 1, argv, NULL, NULL))
8179 {
8180 if (rc == MR_NO_MATCH)
8181 break;
8182 com_err(whoami, 0, "Moira error while creating group name for "
8183 "container %s : %s", ContainerName, error_message(rc));
8184 return rc;
8185 }
8186
8187 sprintf(newGroupName, "%s-%c", tempGroupName, i);
8188
8189 if (i == (int)'z')
8190 {
8191 com_err(whoami, 0, "Unable to find a unique group name for "
8192 "container %s: too many duplicate container names",
8193 ContainerName);
8194 return 1;
8195 }
8196
8197 if (i == '9')
8198 i = 'a';
8199 else
8200 i++;
8201 }
8202
8203 strcpy(GroupName, newGroupName);
8204 return(0);
8205}
8206
8207int Moira_setContainerGroup(char *origContainerName, char *GroupName)
8208{
8209 long rc;
8210 char *argv[3];
8211
8212 argv[0] = origContainerName;
8213 argv[1] = GroupName;
8214
8215 if ((rc = mr_query("set_container_list", 2, argv, NULL, NULL)))
8216 {
8217 com_err(whoami, 0,
8218 "Unable to set container group %s in container %s: %s",
8219 GroupName, origContainerName, error_message(rc));
8220 }
8221
8222 return(0);
8223}
8224
8225int Moira_addGroupToParent(char *origContainerName, char *GroupName)
8226 {
8227 char ContainerName[64];
8228 char ParentGroupName[64];
8229 char *argv[3];
8230 long rc;
8231
8232 strcpy(ContainerName, origContainerName);
8233
8234 Moira_getGroupName(ContainerName, ParentGroupName, 1);
8235
8236 /* top-level container */
8237 if (strlen(ParentGroupName) == 0)
8238 return(0);
8239
8240 argv[0] = ParentGroupName;
8241 argv[1] = "LIST";
8242 argv[2] = GroupName;
8243
8244 if ((rc = mr_query("add_member_to_list", 3, argv, NULL, NULL)))
8245 {
8246 com_err(whoami, 0,
8247 "Unable to add container group %s to parent group %s: %s",
8248 GroupName, ParentGroupName, error_message(rc));
8249 }
8250
8251 return(0);
8252 }
8253
8254int Moira_getContainerGroup(int ac, char **av, void *ptr)
8255{
8256 char **call_args;
8257
8258 call_args = ptr;
8259 strcpy(call_args[0], av[1]);
8260
8261 return(0);
8262}
8263
8264int Moira_getGroupName(char *origContainerName, char *GroupName,
8265 int ParentFlag)
8266{
8267 char ContainerName[64];
8268 char *argv[3];
8269 char *call_args[3];
8270 char *ptr;
8271 long rc;
8272
8273 strcpy(ContainerName, origContainerName);
8274
8275 if (ParentFlag)
8276 {
8277 ptr = strrchr(ContainerName, '/');
8278
8279 if (ptr != NULL)
8280 (*ptr) = '\0';
8281 else
8282 return(0);
8283 }
8284
8285 argv[0] = ContainerName;
8286 argv[1] = NULL;
8287 call_args[0] = GroupName;
8288 call_args[1] = NULL;
8289
8290 if (!(rc = mr_query("get_container_list", 1, argv, Moira_getContainerGroup,
8291 call_args)))
8292 {
8293 if (strlen(GroupName) != 0)
8294 return(0);
8295 }
8296
8297 if (rc)
8298 com_err(whoami, 0, "Unable to get container group from container %s: %s",
8299 ContainerName, error_message(rc));
8300 else
8301 com_err(whoami, 0, "Unable to get container group from container %s",
8302 ContainerName);
8303
8304 return(0);
8305}
8306
8307int Moira_process_machine_container_group(char *MachineName, char* GroupName,
8308 int DeleteMachine)
8309{
8310 char *argv[3];
8311 long rc;
8312
8313 if (strcmp(GroupName, "[none]") == 0)
8314 return 0;
8315
8316 argv[0] = GroupName;
8317 argv[1] = "MACHINE";
8318 argv[2] = MachineName;
8319
8320 if (!DeleteMachine)
8321 rc = mr_query("add_member_to_list", 3, argv, NULL, NULL);
8322 else
8323 rc = mr_query("delete_member_from_list", 3, argv, NULL, NULL);
8324
8325 if (rc)
8326 {
8327 com_err(whoami, 0, "Unable to add machine %s to container group%s: %s",
8328 MachineName, GroupName, error_message(rc));
8329 }
8330
8331 return(0);
8332}
8333
8334int GetMachineName(char *MachineName)
8335{
8336 char *args[2];
8337 char NewMachineName[1024];
8338 char *szDot;
8339 int rc = 0;
8340 int i;
8341 DWORD dwLen = 0;
8342 char *call_args[2];
8343
8344 // If the address happens to be in the top-level MIT domain, great!
8345 strcpy(NewMachineName, MachineName);
8346
8347 for (i = 0; i < (int)strlen(NewMachineName); i++)
8348 NewMachineName[i] = toupper(NewMachineName[i]);
8349
8350 szDot = strchr(NewMachineName,'.');
8351
8352 if ((szDot) && (!strcasecmp(szDot+1, DOMAIN_SUFFIX)))
8353 {
8354 return(0);
8355 }
8356
8357 // If not, see if it has a Moira alias in the top-level MIT domain.
8358 memset(NewMachineName, '\0', sizeof(NewMachineName));
8359 args[0] = "*";
8360 args[1] = MachineName;
8361 call_args[0] = NewMachineName;
8362 call_args[1] = NULL;
8363
8364 if (rc = mr_query("get_hostalias", 2, args, ProcessMachineName, call_args))
8365 {
8366 com_err(whoami, 0, "Unable to resolve machine name %s : %s",
8367 MachineName, error_message(rc));
8368 strcpy(MachineName, "");
8369 return(0);
8370 }
8371
8372 if (strlen(NewMachineName) != 0)
8373 strcpy(MachineName, NewMachineName);
8374 else
8375 strcpy(MachineName, "");
8376
8377 return(0);
8378}
8379
8380int ProcessMachineName(int ac, char **av, void *ptr)
8381{
8382 char **call_args;
8383 char MachineName[1024];
8384 char *szDot;
8385 int i;
8386
8387 call_args = ptr;
8388
8389 if (strlen(call_args[0]) == 0)
8390 {
8391 strcpy(MachineName, av[0]);
8392
8393 for (i = 0; i < (int)strlen(MachineName); i++)
8394 MachineName[i] = toupper(MachineName[i]);
8395
8396 szDot = strchr(MachineName,'.');
8397
8398 if ((szDot) && (!strcasecmp(szDot+1,DOMAIN_SUFFIX)))
8399 {
8400 strcpy(call_args[0], MachineName);
8401 }
8402 }
8403
8404 return(0);
8405}
8406
8407void SwitchSFU(LDAPMod **mods, int *UseSFU30, int n)
8408{
8409 int i;
8410
8411 if (*UseSFU30)
8412 {
8413 for (i = 0; i < n; i++)
8414 {
8415 if (!strcmp(mods[i]->mod_type, "msSFU30UidNumber"))
8416 mods[i]->mod_type = "uidNumber";
8417 }
8418
8419 (*UseSFU30) = 0;
8420 }
8421 else
8422 {
8423 for (i = 0; i < n; i++)
8424 {
8425 if (!strcmp(mods[i]->mod_type, "uidNumber"))
8426 mods[i]->mod_type = "msSFU30UidNumber";
8427 }
8428
8429 (*UseSFU30) = 1;
8430 }
8431}
8432
8433int SetHomeDirectory(LDAP *ldap_handle, char *user_name,
8434 char *DistinguishedName,
8435 char *WinHomeDir, char *WinProfileDir,
8436 char **homedir_v, char **winProfile_v,
8437 char **drives_v, LDAPMod **mods,
8438 int OpType, int n)
8439{
61a2844b 8440 char cWeight[3];
8441 char cPath[1024];
8442 char path[1024];
8443 char winPath[1024];
8444 char winProfile[1024];
8445 char homeDrive[8];
8446 char homedir[1024];
8447 char apple_homedir[1024];
8448 char *apple_homedir_v[] = {NULL, NULL};
8449 int last_weight;
8450 int i;
8451 int rc;
8452 LDAPMod *DelMods[20];
5f6343e6 8453 char *argv[3];
8454 char *save_argv[FS_END];
8455 char *fsgroup_save_argv[2];
8456
61a2844b 8457 memset(homeDrive, '\0', sizeof(homeDrive));
8458 memset(path, '\0', sizeof(path));
8459 memset(winPath, '\0', sizeof(winPath));
8460 memset(winProfile, '\0', sizeof(winProfile));
61a2844b 8461
8462 if(!ActiveDirectory)
8463 {
5f6343e6 8464 if (rc = moira_connect())
8465 {
08d53213 8466 critical_alert(whoami, "Ldap incremental",
5f6343e6 8467 "Error contacting Moira server : %s",
8468 error_message(rc));
8469 return;
8470 }
8471
8472 argv[0] = user_name;
8473
8474 if (!(rc = mr_query("get_filesys_by_label", 1, argv, save_query_info,
8475 save_argv)))
8476 {
8477 if(!strcmp(save_argv[FS_TYPE], "FSGROUP") ||
8478 !strcmp(save_argv[FS_TYPE], "MUL"))
61a2844b 8479 {
5f6343e6 8480
8481 argv[0] = save_argv[FS_NAME];
8482 fsgCount = 0;
8483
8484 if (!(rc = mr_query("get_fsgroup_members", 1, argv,
8485 save_fsgroup_info, fsgroup_save_argv)))
61a2844b 8486 {
5f6343e6 8487 if(fsgCount)
8488 {
8489 argv[0] = fsgroup_save_argv[0];
8490
8491 if (!(rc = mr_query("get_filesys_by_label", 1, argv,
8492 save_query_info, save_argv)))
8493 {
8494 strcpy(path, save_argv[FS_PACK]);
8495 }
8496 }
61a2844b 8497 }
8498 }
5f6343e6 8499 else
8500 {
8501 strcpy(path, save_argv[FS_PACK]);
8502 }
61a2844b 8503 }
5f6343e6 8504
8505 moira_disconnect();
8506
8507 if (strlen(path))
61a2844b 8508 {
5f6343e6 8509 if (!strnicmp(path, AFS, strlen(AFS)))
61a2844b 8510 {
5f6343e6 8511 sprintf(homedir, "%s", path);
8512 sprintf(apple_homedir, "%s/MacData", path);
8513 homedir_v[0] = homedir;
8514 apple_homedir_v[0] = apple_homedir;
61a2844b 8515 ADD_ATTR("homeDirectory", homedir_v, OpType);
8516 ADD_ATTR("apple-user-homeDirectory", apple_homedir_v,
8517 OpType);
8518 }
8519 }
5f6343e6 8520 else
8521 {
8522 homedir_v[0] = "NONE";
8523 apple_homedir_v[0] = "NONE";
8524 ADD_ATTR("homeDirectory", homedir_v, OpType);
8525 ADD_ATTR("apple-user-homeDirectory", apple_homedir_v,
8526 OpType);
8527 }
8528
61a2844b 8529 return(n);
8530 }
5f6343e6 8531
61a2844b 8532 if ((!strcasecmp(WinHomeDir, "[afs]")) ||
8533 (!strcasecmp(WinProfileDir, "[afs]")))
8534 {
5f6343e6 8535 if (rc = moira_connect())
8536 {
08d53213 8537 critical_alert(whoami, "Ldap incremental",
5f6343e6 8538 "Error contacting Moira server : %s",
8539 error_message(rc));
8540 return;
8541 }
8542
8543 argv[0] = user_name;
61a2844b 8544
5f6343e6 8545 if (!(rc = mr_query("get_filesys_by_label", 1, argv, save_query_info,
8546 save_argv)))
8547 {
8548 if(!strcmp(save_argv[FS_TYPE], "FSGROUP") ||
8549 !strcmp(save_argv[FS_TYPE], "MUL"))
8550 {
8551
8552 argv[0] = save_argv[FS_NAME];
8553 fsgCount = 0;
8554
8555 if (!(rc = mr_query("get_fsgroup_members", 1, argv,
8556 save_fsgroup_info, fsgroup_save_argv)))
8557 {
8558 if(fsgCount)
8559 {
8560 argv[0] = fsgroup_save_argv[0];
8561
8562 if (!(rc = mr_query("get_filesys_by_label", 1, argv,
8563 save_query_info, save_argv)))
8564 {
8565 strcpy(path, save_argv[FS_PACK]);
8566 }
8567 }
8568 }
8569 }
8570 else
8571 {
8572 strcpy(path, save_argv[FS_PACK]);
8573 }
8574 }
8575
8576 moira_disconnect();
61a2844b 8577
5f6343e6 8578 if (strlen(path))
8579 {
8580 if (!strnicmp(path, AFS, strlen(AFS)))
8581 {
8582 AfsToWinAfs(path, winPath);
8583 strcpy(winProfile, winPath);
8584 strcat(winProfile, "\\.winprofile");
8585 }
8586 }
61a2844b 8587 else
8588 return(n);
8589 }
8590
8591 if ((!strcasecmp(WinHomeDir, "[dfs]")) ||
8592 (!strcasecmp(WinProfileDir, "[dfs]")))
8593 {
8594 sprintf(path, "\\\\%s\\dfs\\profiles\\%c\\%s", ldap_domain,
8595 user_name[0], user_name);
8596
8597 if (!strcasecmp(WinProfileDir, "[dfs]"))
8598 {
8599 strcpy(winProfile, path);
8600 strcat(winProfile, "\\.winprofile");
8601 }
8602
8603 if (!strcasecmp(WinHomeDir, "[dfs]"))
8604 strcpy(winPath, path);
8605 }
8606
61a2844b 8607 if (!strcasecmp(WinHomeDir, "[local]"))
8608 memset(winPath, '\0', sizeof(winPath));
8609 else if (!strcasecmp(WinHomeDir, "[afs]") ||
8610 !strcasecmp(WinHomeDir, "[dfs]"))
8611 {
8612 strcpy(homeDrive, "H:");
8613 }
8614 else
8615 {
8616 strcpy(winPath, WinHomeDir);
8617 if (!strncmp(WinHomeDir, "\\\\", 2))
8618 {
8619 strcpy(homeDrive, "H:");
8620 }
8621 }
8622
8623 // nothing needs to be done if WinProfileDir is [afs].
8624 if (!strcasecmp(WinProfileDir, "[local]"))
8625 memset(winProfile, '\0', sizeof(winProfile));
8626 else if (strcasecmp(WinProfileDir, "[afs]") &&
8627 strcasecmp(WinProfileDir, "[dfs]"))
8628 {
8629 strcpy(winProfile, WinProfileDir);
8630 }
8631
8632 if (strlen(winProfile) != 0)
8633 {
8634 if (winProfile[strlen(winProfile) - 1] == '\\')
8635 winProfile[strlen(winProfile) - 1] = '\0';
8636 }
8637
8638 if (strlen(winPath) != 0)
8639 {
8640 if (winPath[strlen(winPath) - 1] == '\\')
8641 winPath[strlen(winPath) - 1] = '\0';
8642 }
8643
8644 if ((winProfile[1] == ':') && (strlen(winProfile) == 2))
8645 strcat(winProfile, "\\");
8646
8647 if ((winPath[1] == ':') && (strlen(winPath) == 2))
8648 strcat(winPath, "\\");
8649
8650 if (strlen(winPath) == 0)
8651 {
8652 if (OpType == LDAP_MOD_REPLACE)
8653 {
8654 i = 0;
8655 DEL_ATTR("homeDirectory", LDAP_MOD_DELETE);
8656 DelMods[i] = NULL;
8657 //unset homeDirectory attribute for user.
8658 rc = ldap_modify_s(ldap_handle, DistinguishedName, DelMods);
8659 free(DelMods[0]);
8660 }
8661 }
8662 else
8663 {
8664 homedir_v[0] = strdup(winPath);
8665 ADD_ATTR("homeDirectory", homedir_v, OpType);
8666 }
8667
8668 if (strlen(winProfile) == 0)
8669 {
8670 if (OpType == LDAP_MOD_REPLACE)
8671 {
8672 i = 0;
8673 DEL_ATTR("profilePath", LDAP_MOD_DELETE);
8674 DelMods[i] = NULL;
8675 //unset profilePate attribute for user.
8676 rc = ldap_modify_s(ldap_handle, DistinguishedName, DelMods);
8677 free(DelMods[0]);
8678 }
8679 }
8680 else
8681 {
8682 winProfile_v[0] = strdup(winProfile);
8683 ADD_ATTR("profilePath", winProfile_v, OpType);
8684 }
8685
8686 if (strlen(homeDrive) == 0)
8687 {
8688 if (OpType == LDAP_MOD_REPLACE)
8689 {
8690 i = 0;
8691 DEL_ATTR("homeDrive", LDAP_MOD_DELETE);
8692 DelMods[i] = NULL;
8693 //unset homeDrive attribute for user
8694 rc = ldap_modify_s(ldap_handle, DistinguishedName, DelMods);
8695 free(DelMods[0]);
8696 }
8697 }
8698 else
8699 {
8700 drives_v[0] = strdup(homeDrive);
8701 ADD_ATTR("homeDrive", drives_v, OpType);
8702 }
8703
8704 return(n);
8705}
8706
8707int attribute_update(LDAP *ldap_handle, char *distinguished_name,
8708 char *attribute_value, char *attribute, char *user_name)
8709{
8710 char *mod_v[] = {NULL, NULL};
8711 LDAPMod *DelMods[20];
8712 LDAPMod *mods[20];
8713 int n;
8714 int i;
8715 int rc;
8716
8717 if (strlen(attribute_value) == 0)
8718 {
8719 i = 0;
8720 DEL_ATTR(attribute, LDAP_MOD_DELETE);
8721 DelMods[i] = NULL;
8722 rc = ldap_modify_s(ldap_handle, distinguished_name, DelMods);
8723 free(DelMods[0]);
8724 }
8725 else
8726 {
8727 n = 0;
8728 mod_v[0] = attribute_value;
8729 ADD_ATTR(attribute, mod_v, LDAP_MOD_REPLACE);
8730 mods[n] = NULL;
8731
8732 if ((rc = ldap_modify_s(ldap_handle, distinguished_name,
8733 mods)) != LDAP_SUCCESS)
8734 {
8735 free(mods[0]);
8736 n = 0;
8737 mod_v[0] = attribute_value;
8738 ADD_ATTR(attribute, mod_v, LDAP_MOD_ADD);
8739 mods[n] = NULL;
8740
8741 if ((rc = ldap_modify_s(ldap_handle, distinguished_name,
8742 mods)) != LDAP_SUCCESS)
8743 {
8744 com_err(whoami, 0, "Unable to change the %s attribute for %s "
c9ef9269 8745 "in the directory : %s",
61a2844b 8746 attribute, user_name, ldap_err2string(rc));
8747 }
8748 }
8749
8750 free(mods[0]);
8751 }
8752
8753 return(rc);
8754}
8755
8756void StringTrim(char *StringToTrim)
8757{
8758 char *t, *s;
8759 char *save;
8760
8761 save = strdup(StringToTrim);
8762
8763 s = save;
8764
8765 while (isspace(*s))
8766 s++;
8767
8768 /* skip to end of string */
8769 if (*s == '\0')
8770 {
8771 if (*save)
8772 *save = '\0';
8773 strcpy(StringToTrim, save);
8774 return;
8775 }
8776
8777 for (t = s; *t; t++)
8778 continue;
8779
8780 while (t > s)
8781 {
8782 --t;
8783 if (!isspace(*t))
8784 {
8785 t++;
8786 break;
8787 }
8788 }
8789
8790 if (*t)
8791 *t = '\0';
8792
8793 strcpy(StringToTrim, s);
8794 return;
8795}
8796
8797int ReadConfigFile(char *DomainName)
8798{
8799 int Count;
8800 int i;
8801 int k;
8802 char temp[256];
8803 char temp1[256];
8804 FILE *fptr;
8805
8806 Count = 0;
8807
8808 sprintf(temp, "%s%s.cfg", CFG_PATH, DomainName);
8809
8810 if ((fptr = fopen(temp, "r")) != NULL)
8811 {
8812 while (fgets(temp, sizeof(temp), fptr) != 0)
8813 {
8814 for (i = 0; i < (int)strlen(temp); i++)
8815 temp[i] = toupper(temp[i]);
8816
8817 if (temp[strlen(temp) - 1] == '\n')
8818 temp[strlen(temp) - 1] = '\0';
8819
8820 StringTrim(temp);
8821
8822 if (strlen(temp) == 0)
8823 continue;
8824
8825 if (!strncmp(temp, DOMAIN, strlen(DOMAIN)))
8826 {
8827 if (strlen(temp) > (strlen(DOMAIN)))
8828 {
8829 strcpy(ldap_domain, &temp[strlen(DOMAIN)]);
8830 StringTrim(ldap_domain);
8831 }
8832 }
8833 else if (!strncmp(temp, REALM, strlen(REALM)))
8834 {
8835 if (strlen(temp) > (strlen(REALM)))
8836 {
8837 strcpy(ldap_realm, &temp[strlen(REALM)]);
8838 StringTrim(ldap_realm);
8839 }
8840 }
8841 else if (!strncmp(temp, PORT, strlen(PORT)))
8842 {
8843 if (strlen(temp) > (strlen(PORT)))
8844 {
8845 strcpy(ldap_port, &temp[strlen(PORT)]);
8846 StringTrim(ldap_port);
8847 }
8848 }
8849 else if (!strncmp(temp, PRINCIPALNAME, strlen(PRINCIPALNAME)))
8850 {
8851 if (strlen(temp) > (strlen(PRINCIPALNAME)))
8852 {
8853 strcpy(PrincipalName, &temp[strlen(PRINCIPALNAME)]);
8854 StringTrim(PrincipalName);
8855 }
8856 }
8857 else if (!strncmp(temp, SERVER, strlen(SERVER)))
8858 {
8859 if (strlen(temp) > (strlen(SERVER)))
8860 {
8861 ServerList[Count] = calloc(1, 256);
8862 strcpy(ServerList[Count], &temp[strlen(SERVER)]);
8863 StringTrim(ServerList[Count]);
8864 ++Count;
8865 }
8866 }
8867 else if (!strncmp(temp, MSSFU, strlen(MSSFU)))
8868 {
8869 if (strlen(temp) > (strlen(MSSFU)))
8870 {
8871 strcpy(temp1, &temp[strlen(MSSFU)]);
8872 StringTrim(temp1);
8873 if (!strcmp(temp1, SFUTYPE))
8874 UseSFU30 = 1;
8875 }
8876 }
8877 else if (!strncmp(temp, GROUP_SUFFIX, strlen(GROUP_SUFFIX)))
8878 {
8879 if (strlen(temp) > (strlen(GROUP_SUFFIX)))
8880 {
8881 strcpy(temp1, &temp[strlen(GROUP_SUFFIX)]);
8882 StringTrim(temp1);
8883 if (!strcasecmp(temp1, "NO"))
8884 {
8885 UseGroupSuffix = 0;
8886 memset(group_suffix, '\0', sizeof(group_suffix));
8887 }
8888 }
8889 }
8890 else if (!strncmp(temp, GROUP_TYPE, strlen(GROUP_TYPE)))
8891 {
8892 if (strlen(temp) > (strlen(GROUP_TYPE)))
8893 {
8894 strcpy(temp1, &temp[strlen(GROUP_TYPE)]);
8895 StringTrim(temp1);
8896 if (!strcasecmp(temp1, "UNIVERSAL"))
8897 UseGroupUniversal = 1;
8898 }
8899 }
8900 else if (!strncmp(temp, SET_GROUP_ACE, strlen(SET_GROUP_ACE)))
8901 {
8902 if (strlen(temp) > (strlen(SET_GROUP_ACE)))
8903 {
8904 strcpy(temp1, &temp[strlen(SET_GROUP_ACE)]);
8905 StringTrim(temp1);
8906 if (!strcasecmp(temp1, "NO"))
8907 SetGroupAce = 0;
8908 }
8909 }
8910 else if (!strncmp(temp, SET_PASSWORD, strlen(SET_PASSWORD)))
8911 {
8912 if (strlen(temp) > (strlen(SET_PASSWORD)))
8913 {
8914 strcpy(temp1, &temp[strlen(SET_PASSWORD)]);
8915 StringTrim(temp1);
8916 if (!strcasecmp(temp1, "NO"))
8917 SetPassword = 0;
8918 }
8919 }
8920 else if (!strncmp(temp, EXCHANGE, strlen(EXCHANGE)))
8921 {
8922 if (strlen(temp) > (strlen(EXCHANGE)))
8923 {
8924 strcpy(temp1, &temp[strlen(EXCHANGE)]);
8925 StringTrim(temp1);
8926 if (!strcasecmp(temp1, "YES"))
8927 Exchange = 1;
8928 }
8929 }
8930 else if (!strncmp(temp, PROCESS_MACHINE_CONTAINER,
8931 strlen(PROCESS_MACHINE_CONTAINER)))
8932 {
8933 if (strlen(temp) > (strlen(PROCESS_MACHINE_CONTAINER)))
8934 {
8935 strcpy(temp1, &temp[strlen(PROCESS_MACHINE_CONTAINER)]);
8936 StringTrim(temp1);
8937 if (!strcasecmp(temp1, "NO"))
8938 ProcessMachineContainer = 0;
8939 }
8940 }
8941 else if (!strncmp(temp, ACTIVE_DIRECTORY,
8942 strlen(ACTIVE_DIRECTORY)))
8943 {
8944 if (strlen(temp) > (strlen(ACTIVE_DIRECTORY)))
8945 {
8946 strcpy(temp1, &temp[strlen(ACTIVE_DIRECTORY)]);
8947 StringTrim(temp1);
8948 if (!strcasecmp(temp1, "NO"))
8949 ActiveDirectory = 0;
8950 }
8951 }
e8332ac3 8952 else if (!strncmp(temp, GROUP_POPULATE_MEMBERS,
8953 strlen(GROUP_POPULATE_MEMBERS)))
8954 {
8955 if (strlen(temp) > (strlen(GROUP_POPULATE_MEMBERS)))
8956 {
8957 strcpy(temp1, &temp[strlen(GROUP_POPULATE_MEMBERS)]);
8958 StringTrim(temp1);
8959 if (!strcasecmp(temp1, "DELETE"))
8960 {
8961 GroupPopulateDelete = 1;
8962 }
8963 }
8964 }
8b76dea3 8965 else if (!strncmp(temp, MAX_MEMBERS, strlen(MAX_MEMBERS)))
8966 {
8967 if (strlen(temp) > (strlen(MAX_MEMBERS)))
8968 {
8969 strcpy(temp1, &temp[strlen(MAX_MEMBERS)]);
8970 StringTrim(temp1);
8971 max_group_members = atoi(temp1);
8972 }
8973 }
61a2844b 8974 else
8975 {
8976 if (strlen(ldap_domain) != 0)
8977 {
8978 memset(ldap_domain, '\0', sizeof(ldap_domain));
8979 break;
8980 }
8981
8982 if (strlen(temp) != 0)
8983 strcpy(ldap_domain, temp);
8984 }
8985 }
8986 fclose(fptr);
8987 }
8988
8989 if (strlen(ldap_domain) == 0)
8990 {
8991 strcpy(ldap_domain, DomainName);
8992 }
8993
8994 if (Count == 0)
8995 return(0);
8996
8997 for (i = 0; i < Count; i++)
8998 {
8999 if (ServerList[i] != 0)
9000 {
9001 for (k = 0; k < (int)strlen(ServerList[i]); k++)
9002 ServerList[i][k] = toupper(ServerList[i][k]);
9003 }
9004 }
9005
9006 return(0);
9007}
9008
9009int ReadDomainList()
9010{
9011 int Count;
9012 int i;
9013 char temp[128];
9014 char temp1[128];
9015 FILE *fptr;
9016 unsigned char c[11];
9017 unsigned char stuff[256];
9018 int rc;
9019 int ok;
9020
9021 Count = 0;
9022 sprintf(temp, "%s%s", CFG_PATH, WINADCFG);
9023
9024 if ((fptr = fopen(temp, "r")) != NULL)
9025 {
9026 while (fgets(temp, sizeof(temp), fptr) != 0)
9027 {
9028 for (i = 0; i < (int)strlen(temp); i++)
9029 temp[i] = toupper(temp[i]);
9030
9031 if (temp[strlen(temp) - 1] == '\n')
9032 temp[strlen(temp) - 1] = '\0';
9033
9034 StringTrim(temp);
9035
9036 if (strlen(temp) == 0)
9037 continue;
9038
9039 if (!strncmp(temp, DOMAIN, strlen(DOMAIN)))
9040 {
9041 if (strlen(temp) > (strlen(DOMAIN)))
9042 {
9043 strcpy(temp1, &temp[strlen(DOMAIN)]);
9044 StringTrim(temp1);
9045 strcpy(temp, temp1);
9046 }
9047 }
9048
9049 strcpy(DomainNames[Count], temp);
9050 StringTrim(DomainNames[Count]);
9051 ++Count;
9052 }
9053
9054 fclose(fptr);
9055 }
9056
9057 if (Count == 0)
9058 {
08d53213 9059 critical_alert(whoami, "incremental", "%s", "ldap.incr cannot run due to a "
61a2844b 9060 "configuration error in ldap.cfg");
9061 return(1);
9062 }
9063
9064 return(0);
9065}
9066
9067int email_isvalid(const char *address) {
9068 int count = 0;
9069 const char *c, *domain;
9070 static char *rfc822_specials = "()<>@,;:\\\"[]";
9071
9072 if(address[strlen(address) - 1] == '.')
9073 return 0;
9074
9075 /* first we validate the name portion (name@domain) */
9076 for (c = address; *c; c++) {
9077 if (*c == '\"' && (c == address || *(c - 1) == '.' || *(c - 1) ==
9078 '\"')) {
9079 while (*++c) {
9080 if (*c == '\"')
9081 break;
9082 if (*c == '\\' && (*++c == ' '))
9083 continue;
9084 if (*c <= ' ' || *c >= 127)
9085 return 0;
9086 }
9087
9088 if (!*c++)
9089 return 0;
9090 if (*c == '@')
9091 break;
9092 if (*c != '.')
9093 return 0;
9094 continue;
9095 }
9096
9097 if (*c == '@')
9098 break;
9099 if (*c <= ' ' || *c >= 127)
9100 return 0;
9101 if (strchr(rfc822_specials, *c))
9102 return 0;
9103 }
9104
9105 if (c == address || *(c - 1) == '.')
9106 return 0;
9107
9108 /* next we validate the domain portion (name@domain) */
9109 if (!*(domain = ++c)) return 0;
9110 do {
9111 if (*c == '.') {
9112 if (c == domain || *(c - 1) == '.')
9113 return 0;
9114 count++;
9115 }
9116 if (*c <= ' ' || *c >= 127)
9117 return 0;
9118 if (strchr(rfc822_specials, *c))
9119 return 0;
9120 } while (*++c);
9121
9122 return (count >= 1);
9123}
9124
9125int find_homeMDB(LDAP *ldap_handle, char *dn_path, char **homeMDB,
9126 char **homeServerName)
9127{
9128 LK_ENTRY *group_base;
9129 LK_ENTRY *sub_group_base;
9130 LK_ENTRY *gPtr;
9131 LK_ENTRY *sub_gPtr;
9132 int group_count;
9133 int sub_group_count;
9134 char filter[1024];
9135 char sub_filter[1024];
9136 char search_path[1024];
9137 char range[1024];
9138 char *attr_array[3];
9139 char *s;
9140 int homeMDB_count = -1;
9141 int rc;
9142 int i;
9143 int mdbbl_count;
9144 int rangeStep = 1500;
9145 int rangeLow = 0;
9146 int rangeHigh = rangeLow + (rangeStep - 1);
9147 int isLast = 0;
9148
9149 /* Grumble..... microsoft not making it searchable from the root *grr* */
9150
9151 memset(filter, '\0', sizeof(filter));
9152 memset(search_path, '\0', sizeof(search_path));
9153
9154 sprintf(filter, "(objectClass=msExchMDB)");
9155 sprintf(search_path, "CN=Configuration,%s", dn_path);
9156 attr_array[0] = "distinguishedName";
9157 attr_array[1] = NULL;
9158
9159 group_base = NULL;
9160 group_count = 0;
9161
9162 if ((rc = linklist_build(ldap_handle, search_path, filter, attr_array,
9163 &group_base, &group_count,
9164 LDAP_SCOPE_SUBTREE)) != 0)
9165 {
9166 com_err(whoami, 0, "Unable to find msExchMDB %s",
9167 ldap_err2string(rc));
9168 return(rc);
9169 }
9170
9171 if (group_count)
9172 {
9173 gPtr = group_base;
9174
9175 while(gPtr) {
9176 if (((s = strstr(gPtr->dn, "Public")) != (char *) NULL) ||
9177 ((s = strstr(gPtr->dn, "Recover")) != (char *) NULL) ||
9178 ((s = strstr(gPtr->dn, "Reserve")) != (char *) NULL))
9179 {
9180 gPtr = gPtr->next;
9181 continue;
9182 }
9183
9184 /*
9185 * Due to limits in active directory we need to use the LDAP
9186 * range semantics to query and return all the values in
9187 * large lists, we will stop increasing the range when
9188 * the result count is 0.
9189 */
9190
9191 i = 0;
9192 mdbbl_count = 0;
9193
9194 for(;;)
9195 {
9196 memset(sub_filter, '\0', sizeof(sub_filter));
9197 memset(range, '\0', sizeof(range));
9198 sprintf(sub_filter, "(objectClass=msExchMDB)");
9199
9200 if(isLast)
9201 sprintf(range, "homeMDBBL;Range=%d-*", rangeLow);
9202 else
9203 sprintf(range, "homeMDBBL;Range=%d-%d", rangeLow, rangeHigh);
9204
9205 attr_array[0] = range;
9206 attr_array[1] = NULL;
9207
9208 sub_group_base = NULL;
9209 sub_group_count = 0;
9210
9211 if ((rc = linklist_build(ldap_handle, gPtr->dn, sub_filter,
9212 attr_array, &sub_group_base,
9213 &sub_group_count,
9214 LDAP_SCOPE_SUBTREE)) != 0)
9215 {
9216 com_err(whoami, 0, "Unable to find homeMDBBL %s",
9217 ldap_err2string(rc));
9218 return(rc);
9219 }
9220
9221 if(!sub_group_count)
9222 {
9223 if(isLast)
9224 {
9225 isLast = 0;
9226 rangeLow = 0;
9227 rangeHigh = rangeLow + (rangeStep - 1);
9228 break;
9229 }
9230 else
9231 isLast++;
9232 }
9233
9234 mdbbl_count += sub_group_count;
9235 rangeLow = rangeHigh + 1;
9236 rangeHigh = rangeLow + (rangeStep - 1);
9237 }
9238
9239 /* First time through, need to initialize or update the least used */
9240
9241 com_err(whoami, 0, "Mail store %s, count %d", gPtr->dn,
9242 mdbbl_count);
9243
9244 if(mdbbl_count < homeMDB_count || homeMDB_count == -1)
9245 {
9246 homeMDB_count = mdbbl_count;
9247 *homeMDB = strdup(gPtr->dn);
9248 }
9249
9250 gPtr = gPtr->next;
9251 linklist_free(sub_group_base);
9252 }
9253 }
9254
9255 linklist_free(group_base);
9256
9257 /*
9258 * Ok found the server least allocated need to now query to get its
9259 * msExchHomeServerName so we can set it as a user attribute
9260 */
9261
9262 attr_array[0] = "legacyExchangeDN";
9263 attr_array[1] = NULL;
9264
9265 group_count = 0;
9266 group_base = NULL;
9267
9268 if ((rc = linklist_build(ldap_handle, *homeMDB, filter,
9269 attr_array, &group_base,
9270 &group_count,
9271 LDAP_SCOPE_SUBTREE)) != 0)
9272 {
9273 com_err(whoami, 0, "Unable to find msExchHomeServerName %s",
9274 ldap_err2string(rc));
9275 return(rc);
9276 }
9277
9278 if(group_count)
9279 {
9280 *homeServerName = strdup(group_base->value);
9281 if((s = strrchr(*homeServerName, '/')) != (char *) NULL)
9282 {
9283 *s = '\0';
9284 }
9285 }
9286
9287 linklist_free(group_base);
9288
9289 return(rc);
9290}
9291
9292char *lowercase(char *s)
9293{
9294 char *p;
9295
9296 for (p = s; *p; p++)
9297 {
9298 if (isupper(*p))
9299 *p = tolower(*p);
9300 }
9301 return s;
9302}
9303
9304char *uppercase(char *s)
9305{
9306 char *p;
9307
9308 for (p = s; *p; p++)
9309 {
9310 if (islower(*p))
9311 *p = toupper(*p);
9312 }
9313 return s;
9314}
9315
9316char *escape_string(char *s)
9317{
9318 char *p, *q;
9319 char string[1024];
9320 char temp[1024];
9321 int i = 0;
9322 int spaces = 0;
9323
c95d6ec1 9324 if(ActiveDirectory) {
9325 return strdup(s);
9326 }
9327
61a2844b 9328 memset(string, '\0', sizeof(string));
9329
9330 q = s;
9331
61a2844b 9332 /* Escape any special characters */
9333
9334 for(; *q != '\0'; q++) {
9335 if(*q == ',')
9336 string[i++] = '\\';
9337 if(*q == '+')
9338 string[i++] = '\\';
9339 if(*q == '"')
9340 string[i++] = '\\';
9341 if(*q == '\\')
9342 string[i++] = '\\';
9343 if(*q == '<')
9344 string[i++] = '\\';
9345 if(*q == '>')
9346 string[i++] = '\\';
9347 if(*q == ';')
9348 string[i++] = '\\';
9349 if(*q == '#')
9350 string[i++] = '\\';
9351 if(*q == '=')
9352 string[i++] = '\\';
9353
9354 string[i++] = *q;
9355 }
9356
9357 return strdup(string);
9358}
9359
9360int save_query_info(int argc, char **argv, void *hint)
9361{
9362 int i;
9363 char **nargv = hint;
9364
9365 for(i = 0; i < argc; i++)
9366 nargv[i] = strdup(argv[i]);
9367
9368 return MR_CONT;
9369}
5f6343e6 9370
9371int save_fsgroup_info(int argc, char **argv, void *hint)
9372{
9373 int i;
9374 char **nargv = hint;
9375
9376 if(!fsgCount)
9377 {
9378 for(i = 0; i < argc; i++)
9379 nargv[i] = strdup(argv[i]);
9380
9381 fsgCount++;
9382 }
9383
9384 return MR_CONT;
9385}
d6232129 9386
9387int contains_member(LDAP *ldap_handle, char *dn_path, char *group_name,
9388 char *UserOu, char *user_name)
9389{
9390 char search_filter[1024];
9391 char *attr_array[3];
9392 LK_ENTRY *group_base;
9393 int group_count;
9394 int rc;
9395 char temp[256];
9396
9397 if(ActiveDirectory)
9398 {
9399 sprintf(temp, "CN=%s,%s,%s", user_name, UserOu, dn_path);
9400 }
9401 else
9402 {
9403 if(!strcmp(UserOu, user_ou))
9404 sprintf(temp, "uid=%s,%s,%s", user_name, UserOu, dn_path);
9405 else
9406 sprintf(temp, "CN=%s,%s,%s", user_name, UserOu, dn_path);
9407 }
9408
9409 group_base = NULL;
9410 group_count = 0;
9411
9412 sprintf(search_filter, "(&(objectClass=group)(cn=%s)(member=%s))",
9413 group_name, temp);
9414
9415 attr_array[0] = "mitMoiraId";
9416 attr_array[1] = NULL;
9417
9418 if ((rc = linklist_build(ldap_handle, dn_path, search_filter,
9419 attr_array, &group_base, &group_count,
9420 LDAP_SCOPE_SUBTREE)) != 0)
9421 {
9422 com_err(whoami, 0, "Unable to check group %s for membership of %s : %s",
9423 group_name, user_name, ldap_err2string(rc));
9424 return(-1);
9425 }
9426
9427 if (group_count)
c95d6ec1 9428 {
9429 rc = 1;
9430 }
d6232129 9431 else
c95d6ec1 9432 {
9433 rc = 0;
9434 }
d6232129 9435
9436 linklist_free(group_base);
9437 group_count = 0;
9438 group_base = NULL;
9439
9440 return(rc);
9441}
Moira, the Athena Service Management system
This page took 1.331869 seconds and 5 git commands to generate.