зеркало из https://github.com/mozilla/gecko-dev.git
701 строка
17 KiB
C++
701 строка
17 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
//
|
|
// Address Book API Utility Functions
|
|
// Written by: Rich Pizzarro (rhp@netscape.com)
|
|
// March 1998
|
|
|
|
#include "stdafx.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include "wfemsg.h" // for WFE_MSGGetMaster()
|
|
#include "nsstrseq.h"
|
|
#include "abapi.h"
|
|
#include "abhook.h"
|
|
#include "nabapi.h"
|
|
#include "mapismem.h"
|
|
#include "hiddenfr.h"
|
|
#include "msgcom.h"
|
|
#include "abutils.h"
|
|
#include "abcom.h"
|
|
|
|
extern CNetscapeApp theApp;
|
|
|
|
typedef struct {
|
|
BOOL foundInSearch;
|
|
int attribType;
|
|
AB_AttribID attribID;
|
|
char *ldifName;
|
|
} attribPairsType;
|
|
|
|
// I18N: Please don't touch these strings!
|
|
#define ATTRIB_COUNT 19
|
|
attribPairsType attribArray[] = {
|
|
// FALSE, dn: cn=first last,mail=email
|
|
FALSE, CHAR_VALUE, AB_attribDisplayName, /*AB_attribFullName,*/ "cn: ",
|
|
FALSE, CHAR_VALUE, AB_attribFamilyName, "sn: ",
|
|
FALSE, CHAR_VALUE, AB_attribGivenName, "givenname: ",
|
|
// FALSE, CHAR_VALUE, "top", "objectclass: ",
|
|
// FALSE, CHAR_VALUE, "person", "objectclass: ",
|
|
FALSE, CHAR_VALUE, AB_attribInfo, "description: ",
|
|
FALSE, CHAR_VALUE, AB_attribLocality, "locality: ",
|
|
FALSE, CHAR_VALUE, AB_attribRegion, "st: ",
|
|
FALSE, CHAR_VALUE, AB_attribEmailAddress, "mail: ",
|
|
FALSE, CHAR_VALUE, AB_attribTitle, "title: ",
|
|
FALSE, CHAR_VALUE, AB_attribPOAddress, "postOfficeBox: ",
|
|
FALSE, CHAR_VALUE, AB_attribStreetAddress, "streetaddress: ",
|
|
FALSE, CHAR_VALUE, AB_attribZipCode, "postalcode: ",
|
|
FALSE, CHAR_VALUE, AB_attribCountry, "countryname: ",
|
|
FALSE, CHAR_VALUE, AB_attribWorkPhone, "telephonenumber: ",
|
|
FALSE, CHAR_VALUE, AB_attribFaxPhone, "facsimiletelephonenumber: ",
|
|
FALSE, CHAR_VALUE, AB_attribHomePhone, "homephone: ",
|
|
FALSE, CHAR_VALUE, AB_attribCompanyName, "o: ",
|
|
FALSE, CHAR_VALUE, AB_attribNickName, "xmozillanickname: ",
|
|
FALSE, BOOL_VALUE, AB_attribHTMLMail, "xmozillausehtmlmail: ",
|
|
FALSE, INT_VALUE, AB_attribUseServer, "xmozillauseconferenceserver: "};
|
|
|
|
BOOL
|
|
TackOnAttributeValuePair(MSG_Pane *abPane, LONG userIndex,
|
|
LPSTR outString, AB_AttribID attribID, LPSTR stringKey,
|
|
DWORD typeOfValue, LPSTR concatString)
|
|
{
|
|
int result;
|
|
AB_AttributeValue *value;
|
|
|
|
if (!outString)
|
|
return FALSE;
|
|
|
|
result = AB_GetEntryAttributeForPane(abPane, userIndex, attribID, &value);
|
|
if (result != 0)
|
|
return FALSE;
|
|
|
|
|
|
if (typeOfValue == CHAR_VALUE)
|
|
{
|
|
// Do the key name first...
|
|
if ( (value->u.string != NULL) && (value->u.string[0] != '\0') )
|
|
{
|
|
lstrcat(outString, stringKey);
|
|
lstrcat(outString, (char *)value->u.string);
|
|
|
|
if (concatString)
|
|
lstrcat(outString, concatString);
|
|
}
|
|
}
|
|
else if (typeOfValue == BOOL_VALUE)
|
|
{
|
|
// Do the key name first...
|
|
lstrcat(outString, stringKey);
|
|
|
|
if (value->u.boolValue)
|
|
lstrcat(outString, "TRUE");
|
|
else
|
|
lstrcat(outString, "FALSE");
|
|
|
|
if (concatString)
|
|
lstrcat(outString, concatString);
|
|
}
|
|
else if (typeOfValue == INT_VALUE)
|
|
{
|
|
char tval[16];
|
|
|
|
// Do the key name first...
|
|
lstrcat(outString, stringKey);
|
|
|
|
wsprintf(tval, "%d", value->u.shortValue);
|
|
lstrcat(outString, tval);
|
|
if (concatString)
|
|
lstrcat(outString, concatString);
|
|
}
|
|
|
|
AB_FreeEntryAttributeValue(value);
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL
|
|
GetLDIFLineForUser(MSG_Pane *abPane, LONG userIndex, LPSTR outString,
|
|
NABUserID *userID, NABUpdateTime *updtTime)
|
|
{
|
|
ABID id;
|
|
int i;
|
|
BOOL rc;
|
|
|
|
if (!outString)
|
|
return FALSE;
|
|
|
|
outString[0] = '\0';
|
|
lstrcpy(outString, "dn: ");
|
|
|
|
rc = TackOnAttributeValuePair(abPane, userIndex, outString, AB_attribFullName,
|
|
"cn: ", CHAR_VALUE, ",");
|
|
if (!rc)
|
|
return FALSE;
|
|
rc = TackOnAttributeValuePair(abPane, userIndex, outString, AB_attribEmailAddress, "mail: ",
|
|
CHAR_VALUE, NAB_CRLF);
|
|
if (!rc)
|
|
return FALSE;
|
|
|
|
for (i=0; i<ATTRIB_COUNT; i++)
|
|
{
|
|
(void) TackOnAttributeValuePair(abPane, userIndex, outString,
|
|
attribArray[i].attribID,
|
|
attribArray[i].ldifName,
|
|
attribArray[i].attribType, NAB_CRLF);
|
|
}
|
|
|
|
// Get the ABID...
|
|
int result = AB_GetABIDForIndex(abPane, userIndex, &id);
|
|
if (result != 0)
|
|
return FALSE;
|
|
|
|
*userID = id;
|
|
*updtTime = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
static HFILE hHTMLFile = NULL;
|
|
|
|
BOOL
|
|
OpenNABAPIHTMLFile(LPSTR fName, LPSTR title)
|
|
{
|
|
hHTMLFile = _lcreat(fName, 0);
|
|
if (hHTMLFile == HFILE_ERROR)
|
|
return FALSE;
|
|
|
|
if ( _lwrite(hHTMLFile, HTML_HEAD1, lstrlen(HTML_HEAD1)) == HFILE_ERROR)
|
|
{
|
|
_lclose(hHTMLFile);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( _lwrite(hHTMLFile, title, lstrlen(title)) == HFILE_ERROR)
|
|
{
|
|
_lclose(hHTMLFile);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( _lwrite(hHTMLFile, HMTL_HEAD2, lstrlen(HMTL_HEAD2)) == HFILE_ERROR)
|
|
{
|
|
_lclose(hHTMLFile);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
CloseNABAPIHTMLFile(void)
|
|
{
|
|
if ( _lwrite(hHTMLFile, HTML_TAIL, lstrlen(HTML_TAIL)) == HFILE_ERROR)
|
|
{
|
|
_lclose(hHTMLFile);
|
|
return FALSE;
|
|
}
|
|
|
|
_lclose(hHTMLFile);
|
|
hHTMLFile = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
#define HTMLSTART 1
|
|
#define HTMLEND 2
|
|
#define HTMLBREAK 3
|
|
#define HTMLSPACE 4
|
|
#define HTMLCOMMA 5
|
|
#define HTMLNEWROW 6
|
|
#define HTMLENDROW 7
|
|
|
|
BOOL
|
|
DumpHTMLForTable(BOOL hType)
|
|
{
|
|
LPSTR cstart = "<TD>";
|
|
LPSTR cend = "</TD>\n";
|
|
LPSTR cbreak = "<BR>";
|
|
LPSTR cspace = " ";
|
|
LPSTR ccomma = ", ";
|
|
LPSTR cnewrow = "<TR>\n";
|
|
LPSTR cendrow = "</TR>\n";
|
|
LPSTR ptr;
|
|
|
|
if (hType == HTMLSTART)
|
|
ptr = cstart;
|
|
else if (hType == HTMLEND)
|
|
ptr = cend;
|
|
else if (hType == HTMLSPACE)
|
|
ptr = cspace;
|
|
else if (hType == HTMLCOMMA)
|
|
ptr = ccomma;
|
|
else if (hType == HTMLNEWROW)
|
|
ptr = cnewrow;
|
|
else if (hType == HTMLENDROW)
|
|
ptr = cendrow;
|
|
else
|
|
ptr = cbreak;
|
|
|
|
if ( _lwrite(hHTMLFile, ptr, lstrlen(ptr)) == HFILE_ERROR)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
DumpHTMLValue(MSG_Pane *abPane, LONG userIndex, AB_AttribID attribID)
|
|
{
|
|
int result;
|
|
AB_AttributeValue *value;
|
|
|
|
result = AB_GetEntryAttributeForPane(abPane, userIndex, attribID, &value);
|
|
if (result != 0)
|
|
return FALSE;
|
|
|
|
if ( (value->u.string != NULL) && (value->u.string[0] != '\0') )
|
|
{
|
|
if ( _lwrite(hHTMLFile, value->u.string, lstrlen(value->u.string)) == HFILE_ERROR)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
DumpHTMLTableLineForUser(MSG_Pane *abPane, LONG userIndex)
|
|
{
|
|
DumpHTMLForTable(HTMLNEWROW);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribFamilyName);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribGivenName);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribEmailAddress);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
if (DumpHTMLValue(abPane, userIndex, AB_attribCompanyName))
|
|
DumpHTMLForTable(HTMLBREAK);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribTitle);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribWorkPhone);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribFaxPhone);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribHomePhone);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLSTART);
|
|
if (DumpHTMLValue(abPane, userIndex, AB_attribPOAddress))
|
|
DumpHTMLForTable(HTMLBREAK);
|
|
if (DumpHTMLValue(abPane, userIndex, AB_attribStreetAddress))
|
|
DumpHTMLForTable(HTMLBREAK);
|
|
|
|
if (DumpHTMLValue(abPane, userIndex, AB_attribLocality))
|
|
DumpHTMLForTable(HTMLCOMMA);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribRegion);
|
|
if (DumpHTMLValue(abPane, userIndex, AB_attribZipCode))
|
|
DumpHTMLForTable(HTMLBREAK);
|
|
DumpHTMLValue(abPane, userIndex, AB_attribCountry);
|
|
DumpHTMLForTable(HTMLEND);
|
|
|
|
DumpHTMLForTable(HTMLENDROW);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
FindAttributeInLine(LPSTR attribName, LPSTR addLine)
|
|
{
|
|
DWORD totlen, complen, i;
|
|
|
|
if ( (!attribName) || !(*attribName) )
|
|
return FALSE;
|
|
|
|
if ( (!addLine) || !(*addLine) )
|
|
return FALSE;
|
|
|
|
i = 0;
|
|
totlen = strlen(addLine);
|
|
complen = strlen(attribName);
|
|
|
|
while ( (i + complen) <= totlen )
|
|
{
|
|
if (strncmp( attribName, addLine+i, complen ) == 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LPSTR
|
|
ExtractAttribValue(LPSTR attribName, LPSTR searchLine)
|
|
{
|
|
DWORD totlen, complen, i;
|
|
|
|
if ( (!attribName) || !(*searchLine) )
|
|
return NULL;
|
|
|
|
if ( (!searchLine) || !(*searchLine) )
|
|
return NULL;
|
|
|
|
i = 0;
|
|
totlen = strlen(searchLine);
|
|
complen = strlen(attribName);
|
|
|
|
while ( (i + complen) <= totlen )
|
|
{
|
|
if (strncmp( attribName, searchLine+i, complen ) == 0)
|
|
{
|
|
if (i+complen == totlen) // Check if we are at the end...
|
|
return NULL;
|
|
|
|
LPSTR newPtr;
|
|
LPSTR startPtr;
|
|
LPSTR endPtr;
|
|
DWORD totalSize;
|
|
|
|
// Have to add this hack for the fact we have an attribute that
|
|
// is a subset of another (i.e. "mail: " and "xmozillausehtmlmail: ")
|
|
if (
|
|
(strcmp(attribName, "mail: ") == 0) && (i > 0) &&
|
|
(*(searchLine+i-1) == 'l' )
|
|
)
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
// end of hack
|
|
|
|
startPtr = searchLine + (i + complen);
|
|
endPtr = startPtr;
|
|
|
|
while ( ((*endPtr) != '\0') && ((*endPtr) != '\r') )
|
|
{
|
|
endPtr = (endPtr + 1);
|
|
}
|
|
|
|
totalSize = (endPtr - startPtr) + 1;
|
|
newPtr = (LPSTR) malloc(totalSize);
|
|
if (!newPtr)
|
|
return NULL;
|
|
|
|
memset(newPtr, 0, totalSize);
|
|
strncpy(newPtr, startPtr, (totalSize - 1));
|
|
return newPtr;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL
|
|
ThisIsAStringAttrib(AB_AttribID attrib)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<ATTRIB_COUNT; i++)
|
|
{
|
|
if (attribArray[i].attribID == attrib)
|
|
{
|
|
if (attribArray[i].attribType == CHAR_VALUE)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// Inserting Address Book Entires...
|
|
NABError
|
|
InsertEntryToAB(AB_ContainerInfo *abContainer, LPSTR newLine,
|
|
BOOL updateOnly, ABID *updateID)
|
|
{
|
|
ULONG i;
|
|
DWORD numItems = 0;
|
|
ABID tempEntryID;
|
|
AB_AttributeValue *values;
|
|
BOOL found;
|
|
USHORT currentAttribLoc;
|
|
|
|
// Build the entries to add for the address book...
|
|
for (i=0; i<ATTRIB_COUNT; i++)
|
|
{
|
|
attribArray[i].foundInSearch = FindAttributeInLine(attribArray[i].ldifName, newLine);
|
|
if (found)
|
|
numItems++;
|
|
}
|
|
|
|
if (numItems == 0)
|
|
return(NAB_FAILURE);
|
|
|
|
++numItems; // add one for the type...
|
|
|
|
// Now that we have this information, malloc the memory needed and
|
|
// move on...
|
|
values = (AB_AttributeValue *) malloc(sizeof(AB_AttributeValue) * numItems);
|
|
if (!values)
|
|
return(NAB_MEMORY_FAILURE);
|
|
|
|
memset(values, 0, (sizeof(AB_AttributeValue) * numItems));
|
|
|
|
// First should be the type of entry...
|
|
values[0].attrib = AB_attribEntryType;
|
|
values[0].u.entryType = AB_Person;
|
|
|
|
LPSTR ptr;
|
|
currentAttribLoc = 1;
|
|
for (i=0; i<ATTRIB_COUNT; i++)
|
|
{
|
|
if (attribArray[i].foundInSearch)
|
|
{
|
|
if ( (ptr = ExtractAttribValue(attribArray[i].ldifName, newLine)) == NULL)
|
|
continue;
|
|
|
|
// Here?...then we found it!
|
|
values[currentAttribLoc].attrib = attribArray[i].attribID;
|
|
if (attribArray[i].attribType == CHAR_VALUE)
|
|
{
|
|
values[currentAttribLoc].u.string = ptr;
|
|
}
|
|
else if (attribArray[i].attribType == BOOL_VALUE)
|
|
{
|
|
if (strcmp(ptr, "TRUE") == 0)
|
|
values[currentAttribLoc].u.boolValue = TRUE;
|
|
else
|
|
values[currentAttribLoc].u.boolValue = FALSE;
|
|
free(ptr);
|
|
}
|
|
else if (attribArray[i].attribType == INT_VALUE)
|
|
{
|
|
values[currentAttribLoc].u.shortValue = atoi(ptr);
|
|
free(ptr);
|
|
}
|
|
|
|
currentAttribLoc++;
|
|
}
|
|
}
|
|
|
|
int result;
|
|
if (updateOnly)
|
|
{
|
|
result = AB_SetEntryAttributes(abContainer, *updateID, values, currentAttribLoc);
|
|
}
|
|
else
|
|
{
|
|
result = AB_AddUserAB2(abContainer, values, currentAttribLoc, &tempEntryID);
|
|
*updateID = tempEntryID;
|
|
}
|
|
|
|
// Now free all allocated memory...
|
|
for (i=1; i<currentAttribLoc; i++) // start from 1 - 0 is AB_attribEntryType
|
|
{
|
|
if (ThisIsAStringAttrib(values[i].attrib))
|
|
{
|
|
if (values[i].u.string != NULL)
|
|
free(values[i].u.string);
|
|
}
|
|
}
|
|
|
|
free(values);
|
|
|
|
if (result)
|
|
return NAB_FAILURE;
|
|
else
|
|
return NAB_SUCCESS;
|
|
}
|
|
|
|
BOOL
|
|
GetIDSearchField(LPSTR ldifInfo, DWORD *id, LPSTR *searchValue)
|
|
{
|
|
LPSTR ptr;
|
|
DWORD i;
|
|
|
|
for (i=0; i<ATTRIB_COUNT; i++)
|
|
{
|
|
if (attribArray[i].attribType != CHAR_VALUE)
|
|
continue;
|
|
|
|
ptr = ExtractAttribValue(attribArray[i].ldifName, ldifInfo);
|
|
if (ptr != NULL)
|
|
{
|
|
*id = attribArray[i].attribID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!ptr)
|
|
return FALSE;
|
|
else
|
|
{
|
|
*searchValue = ptr;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
FindValueForIDInLine(MSG_Pane *addressBookPane, LONG userIndex,
|
|
AB_AttribID id, LPSTR searchValue)
|
|
{
|
|
int result;
|
|
AB_AttributeValue *value;
|
|
BOOL found = FALSE;
|
|
|
|
if ((!searchValue) || (!*searchValue))
|
|
return FALSE;
|
|
|
|
result = AB_GetEntryAttributeForPane(addressBookPane, userIndex, id, &value);
|
|
if (result != 0)
|
|
return FALSE;
|
|
|
|
// Do the key name first...
|
|
if ( (value->u.string != NULL) && (value->u.string[0] != '\0') )
|
|
{
|
|
if ( strlen(value->u.string) >= strlen(searchValue) )
|
|
{
|
|
if (_strnicmp(value->u.string, searchValue, strlen(searchValue)) == 0)
|
|
{
|
|
found = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
AB_FreeEntryAttributeValue(value);
|
|
return(found);
|
|
}
|
|
|
|
BOOL
|
|
SearchABForAttrib(AB_ContainerInfo *abContainer,
|
|
LPSTR searchAttrib,
|
|
LPSTR ldifInfo,
|
|
NABUserID *userID,
|
|
NABUpdateTime *updtTime)
|
|
{
|
|
int result;
|
|
MSG_Pane *addressBookPane; // Container info for a particular addr book
|
|
|
|
result = AB_CreateABPane(&addressBookPane, theApp.m_pAddressContext, WFE_MSGGetMaster());
|
|
if (result)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
result = AB_InitializeABPane(addressBookPane, abContainer);
|
|
if (result)
|
|
{
|
|
AB_ClosePane(addressBookPane);
|
|
return(FALSE);
|
|
}
|
|
|
|
DWORD id;
|
|
int currentLocation = 0;
|
|
LONG lineCount = MSG_GetNumLines(addressBookPane);
|
|
LPSTR searchValue = NULL;
|
|
BOOL found = FALSE;
|
|
|
|
//
|
|
// Support lookups by ABID's...
|
|
if ((searchAttrib == NULL) || (searchAttrib[0] == '\0'))
|
|
{
|
|
while ( currentLocation < lineCount )
|
|
{
|
|
ABID id;
|
|
|
|
// Get the ABID...
|
|
int result = AB_GetABIDForIndex(addressBookPane, currentLocation, &id);
|
|
if (result != 0)
|
|
{
|
|
++currentLocation;
|
|
continue;
|
|
}
|
|
|
|
if (id == *userID)
|
|
{
|
|
found = TRUE;
|
|
if (!GetLDIFLineForUser(addressBookPane, currentLocation, ldifInfo, userID, updtTime))
|
|
{
|
|
found = FALSE;
|
|
currentLocation++;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// Increment for next call...
|
|
currentLocation++;
|
|
}
|
|
|
|
AB_ClosePane(addressBookPane);
|
|
return found;
|
|
}
|
|
// Support lookups by ABID's...
|
|
//
|
|
|
|
if (!GetIDSearchField(searchAttrib, &id, &searchValue))
|
|
{
|
|
AB_ClosePane(addressBookPane);
|
|
return(FALSE);
|
|
}
|
|
|
|
while ( currentLocation < lineCount )
|
|
{
|
|
found = FindValueForIDInLine(addressBookPane, currentLocation,
|
|
(AB_AttribID)id, searchValue);
|
|
if (found)
|
|
{
|
|
if (!GetLDIFLineForUser(addressBookPane, currentLocation, ldifInfo, userID, updtTime))
|
|
{
|
|
found = FALSE;
|
|
currentLocation++;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Increment for next call...
|
|
currentLocation++;
|
|
}
|
|
|
|
if (searchValue != NULL)
|
|
free(searchValue);
|
|
|
|
AB_ClosePane(addressBookPane);
|
|
return found;
|
|
}
|
|
|