mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-12 14:37:50 +00:00
1875 lines
47 KiB
C++
1875 lines
47 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 Hooks for Communicator
|
|
// Note: THIS LIVES IN COMMUNICATOR THOUGH IT IS IN THE ABAPI FOR
|
|
// BUILD REASONS
|
|
// Written by: Rich Pizzarro (rhp@netscape.com)
|
|
// March 1998
|
|
|
|
#ifdef NSCPNABAPIDLL // Is this part of the DLL or Communicator?
|
|
#include <windows.h>
|
|
#include <trace.h>
|
|
#else
|
|
#include "stdafx.h"
|
|
#endif
|
|
|
|
#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 "abcom.h"
|
|
#include "abutils.h"
|
|
|
|
extern CNetscapeApp theApp;
|
|
|
|
//
|
|
// Static defines for the Address Book support...
|
|
//
|
|
static CNABConnection *nabConnections[MAX_CON] = {NULL, NULL, NULL, NULL};
|
|
|
|
//
|
|
// Forward declarations...
|
|
//
|
|
LONG ProcessNAB_Open(NAB_OpenType *openPtr);
|
|
LONG ProcessNAB_Close(NAB_CloseType *closePtr);
|
|
LONG ProcessNAB_GetAddressBookList(NAB_GetAddressBookListType *getPtr);
|
|
LONG ProcessNAB_GetDefaultAddressBook(NAB_GetDefaultAddressBookType *getPtr);
|
|
LONG ProcessNAB_CreatePersonalAddressBook(NAB_CreatePersonalAddressBookType *createPtr);
|
|
LONG ProcessNAB_SaveAddressBookToHTML(NAB_SaveAddressBookToHTMLType *savePtr);
|
|
LONG ProcessNAB_ImportLDIFFile(NAB_ImportLDIFFileType *importPtr);
|
|
LONG ProcessNAB_ExportLDIFFile(NAB_ExportLDIFFileType *exportPtr);
|
|
LONG ProcessNAB_GetFirstAddressBookEntry(NAB_GetFirstAddressBookEntryType *getPtr);
|
|
LONG ProcessNAB_GetNextAddressBookEntry(NAB_GetNextAddressBookEntryType *getPtr);
|
|
LONG ProcessNAB_FindAddressBookEntry(NAB_FindAddressBookEntryType *findPtr);
|
|
LONG ProcessNAB_InsertAddressBookEntry(NAB_InsertAddressBookEntryType *insertPtr);
|
|
LONG ProcessNAB_UpdateAddressBookEntry(NAB_UpdateAddressBookEntryType *updatePtr);
|
|
LONG ProcessNAB_DeleteAddressBookEntry(NAB_DeleteAddressBookEntryType *deletePtr);
|
|
|
|
//
|
|
// This will store the CFrameWnd we startup for the Address Book API and if we
|
|
// do start an instance of the browser, we will close it out when we leave.
|
|
//
|
|
static CFrameWnd *pNABFrameWnd = NULL;
|
|
|
|
void
|
|
StoreNABFrameWnd(CFrameWnd *pFrameWnd)
|
|
{
|
|
pNABFrameWnd = pFrameWnd;
|
|
}
|
|
|
|
// This is the result of a WM_COPYDATA message. This will be used to send requests
|
|
// into Communicator for Address Book API requests.
|
|
//
|
|
// The description of the parameters coming into this call are:
|
|
//
|
|
// wParam = (WPARAM) (HWND) hwnd; // handle of sending window
|
|
// lParam = (LPARAM) (PCOPYDATASTRUCT) pcds; // pointer to structure with data
|
|
// context= needed for the context we will use in Communicator
|
|
//
|
|
// typedef struct tagCOPYDATASTRUCT { // cds
|
|
// DWORD dwData; // the ID of the request
|
|
// DWORD cbData; // the size of the argument
|
|
// PVOID lpData; // Chunk of information defined specifically for each of the
|
|
// // Address Book API Calls.
|
|
// } COPYDATASTRUCT;
|
|
//
|
|
// Returns: The Address Book API Return code for the operation:
|
|
//
|
|
//
|
|
LONG
|
|
ProcessNetscapeNABHook(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PCOPYDATASTRUCT pcds = (PCOPYDATASTRUCT) lParam;
|
|
NABIPCType *ipcInfo;
|
|
#ifdef WIN32
|
|
HANDLE hSharedMemory;
|
|
#endif
|
|
|
|
if (lParam == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
//
|
|
// Get shared memory info structure pointer...
|
|
//
|
|
ipcInfo = (NABIPCType *)pcds->lpData;
|
|
if (ipcInfo == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
//
|
|
// Now connect to shared memory...or just set the
|
|
// pointer for Win16
|
|
//
|
|
#ifdef WIN32
|
|
CSharedMem *sMem = NSOpenExistingSharedMemory((LPCTSTR) ipcInfo->smemName, &hSharedMemory);
|
|
if (!sMem)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
#else
|
|
if (!ipcInfo->lpsmem)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
#endif
|
|
|
|
TRACE("NAB: NABHook Message ID = %d\n", pcds->dwData);
|
|
switch (pcds->dwData)
|
|
{
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_Open
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_Open:
|
|
{
|
|
NAB_OpenType *openInfo;
|
|
#ifdef WIN32
|
|
openInfo = (NAB_OpenType *) &(sMem->m_buf[0]);
|
|
#else
|
|
openInfo = (NAB_OpenType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!openInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
openInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_Open(openInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_Close
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_Close:
|
|
{
|
|
NAB_CloseType *closeInfo;
|
|
#ifdef WIN32
|
|
closeInfo = (NAB_CloseType *) &(sMem->m_buf[0]);
|
|
#else
|
|
closeInfo = (NAB_CloseType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!closeInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
closeInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_Close(closeInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_GetAddressBookList
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_GetAddressBookList:
|
|
{
|
|
NAB_GetAddressBookListType *getInfo;
|
|
#ifdef WIN32
|
|
getInfo = (NAB_GetAddressBookListType *) &(sMem->m_buf[0]);
|
|
#else
|
|
getInfo = (NAB_GetAddressBookListType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!getInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
getInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_GetAddressBookList(getInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_GetDefaultAddressBook
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_GetDefaultAddressBook:
|
|
{
|
|
NAB_GetDefaultAddressBookType *getInfo;
|
|
#ifdef WIN32
|
|
getInfo = (NAB_GetDefaultAddressBookType *) &(sMem->m_buf[0]);
|
|
#else
|
|
getInfo = (NAB_GetDefaultAddressBookType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!getInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
getInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_GetDefaultAddressBook(getInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_CreatePersonalAddressBook
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_CreatePersonalAddressBook:
|
|
{
|
|
NAB_CreatePersonalAddressBookType *createInfo;
|
|
#ifdef WIN32
|
|
createInfo = (NAB_CreatePersonalAddressBookType *) &(sMem->m_buf[0]);
|
|
#else
|
|
createInfo = (NAB_CreatePersonalAddressBookType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!createInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
createInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_CreatePersonalAddressBook(createInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_SaveAddressBookToHTML
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_SaveAddressBookToHTML:
|
|
{
|
|
NAB_SaveAddressBookToHTMLType *saveInfo;
|
|
#ifdef WIN32
|
|
saveInfo = (NAB_SaveAddressBookToHTMLType *) &(sMem->m_buf[0]);
|
|
#else
|
|
saveInfo = (NAB_SaveAddressBookToHTMLType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!saveInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
saveInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_SaveAddressBookToHTML(saveInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_ImportLDIFFile
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_ImportLDIFFile:
|
|
{
|
|
NAB_ImportLDIFFileType *importInfo;
|
|
#ifdef WIN32
|
|
importInfo = (NAB_ImportLDIFFileType *) &(sMem->m_buf[0]);
|
|
#else
|
|
importInfo = (NAB_ImportLDIFFileType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!importInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
importInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_ImportLDIFFile(importInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_ExportLDIFFile
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_ExportLDIFFile:
|
|
{
|
|
NAB_ExportLDIFFileType *exportInfo;
|
|
#ifdef WIN32
|
|
exportInfo = (NAB_ExportLDIFFileType *) &(sMem->m_buf[0]);
|
|
#else
|
|
exportInfo = (NAB_ExportLDIFFileType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!exportInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
exportInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_ExportLDIFFile(exportInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_GetFirstAddressBookEntry
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_GetFirstAddressBookEntry:
|
|
{
|
|
NAB_GetFirstAddressBookEntryType *getInfo;
|
|
#ifdef WIN32
|
|
getInfo = (NAB_GetFirstAddressBookEntryType *) &(sMem->m_buf[0]);
|
|
#else
|
|
getInfo = (NAB_GetFirstAddressBookEntryType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!getInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
getInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_GetFirstAddressBookEntry(getInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_GetNextAddressBookEntry
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_GetNextAddressBookEntry:
|
|
{
|
|
NAB_GetNextAddressBookEntryType *getInfo;
|
|
#ifdef WIN32
|
|
getInfo = (NAB_GetNextAddressBookEntryType *) &(sMem->m_buf[0]);
|
|
#else
|
|
getInfo = (NAB_GetNextAddressBookEntryType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!getInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
getInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_GetNextAddressBookEntry(getInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_FindAddressBookEntry
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_FindAddressBookEntry:
|
|
{
|
|
NAB_FindAddressBookEntryType *findInfo;
|
|
#ifdef WIN32
|
|
findInfo = (NAB_FindAddressBookEntryType *) &(sMem->m_buf[0]);
|
|
#else
|
|
findInfo = (NAB_FindAddressBookEntryType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!findInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
findInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_FindAddressBookEntry(findInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_InsertAddressBookEntry
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_InsertAddressBookEntry:
|
|
{
|
|
NAB_InsertAddressBookEntryType *insertInfo;
|
|
#ifdef WIN32
|
|
insertInfo = (NAB_InsertAddressBookEntryType *) &(sMem->m_buf[0]);
|
|
#else
|
|
insertInfo = (NAB_InsertAddressBookEntryType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!insertInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
insertInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_InsertAddressBookEntry(insertInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_UpdateAddressBookEntry
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_UpdateAddressBookEntry:
|
|
{
|
|
NAB_UpdateAddressBookEntryType *updateInfo;
|
|
#ifdef WIN32
|
|
updateInfo = (NAB_UpdateAddressBookEntryType *) &(sMem->m_buf[0]);
|
|
#else
|
|
updateInfo = (NAB_UpdateAddressBookEntryType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!updateInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
updateInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_UpdateAddressBookEntry(updateInfo));
|
|
break;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// NAB_DeleteAddressBookEntry
|
|
//////////////////////////////////////////////////////////////////////
|
|
case NSCP_NAB_DeleteAddressBookEntry:
|
|
{
|
|
NAB_DeleteAddressBookEntryType *deleteInfo;
|
|
#ifdef WIN32
|
|
deleteInfo = (NAB_DeleteAddressBookEntryType *) &(sMem->m_buf[0]);
|
|
#else
|
|
deleteInfo = (NAB_DeleteAddressBookEntryType *) ipcInfo->lpsmem;
|
|
#endif
|
|
|
|
if (!deleteInfo)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
deleteInfo->ipcWorked = 1; // Set the worked flag
|
|
return(ProcessNAB_DeleteAddressBookEntry(deleteInfo));
|
|
break;
|
|
}
|
|
|
|
case NSCP_NAB_FreeMemory: // This should never hit Communicator, but if it does
|
|
return(NAB_SUCCESS); // Just return
|
|
|
|
default:
|
|
return(NAB_FAILURE); // Should never hit here!
|
|
break;
|
|
}
|
|
|
|
return(NAB_SUCCESS);
|
|
}
|
|
|
|
//
|
|
// CNABConnections object...should be in their own file...
|
|
//
|
|
CNABConnection::CNABConnection ( LONG id )
|
|
{
|
|
int result;
|
|
|
|
m_nameIndex = 0;
|
|
m_nameTotalCount = 0;
|
|
m_sessionCount = 1;
|
|
m_defaultConnection = FALSE;
|
|
m_ID = (id + 1); // since zero is invalid, but have to make sure we
|
|
// decrement by one when it is passed in again.
|
|
m_nameIndex = -1; // For tracing our way through the FindNext operation
|
|
|
|
m_ContainerPane = NULL; // Container Pane...
|
|
m_ContainerArray = NULL; // The array of container info pointers...
|
|
m_AddressBookPane = NULL;
|
|
m_ContainerArrayCount = 0;
|
|
|
|
result = AB_CreateContainerPane(&m_ContainerPane,
|
|
theApp.m_pAddressContext,
|
|
WFE_MSGGetMaster()) ;
|
|
if (result)
|
|
return;
|
|
|
|
result = AB_InitializeContainerPane(m_ContainerPane);
|
|
if (result)
|
|
{
|
|
AB_ClosePane (m_ContainerPane);
|
|
m_ContainerPane = NULL;
|
|
return;
|
|
}
|
|
|
|
RefreshABContainerList();
|
|
}
|
|
|
|
CNABConnection::~CNABConnection ( )
|
|
{
|
|
AB_ClosePane( m_ContainerPane );
|
|
m_ContainerPane = NULL;
|
|
|
|
if (m_ContainerArray != NULL)
|
|
{
|
|
free(m_ContainerArray);
|
|
m_ContainerArray = NULL;
|
|
}
|
|
|
|
m_ContainerArrayCount = 0;
|
|
|
|
if (m_AddressBookPane != NULL)
|
|
{
|
|
AB_ClosePane(m_AddressBookPane);
|
|
m_AddressBookPane = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
CNABConnection::RefreshABContainerList ( void )
|
|
{
|
|
int result;
|
|
|
|
if (m_ContainerArray != NULL)
|
|
{
|
|
free(m_ContainerArray);
|
|
m_ContainerArray = NULL;
|
|
m_ContainerArrayCount = 0;
|
|
}
|
|
|
|
// Do the querying stuff for AB API!
|
|
result = AB_GetNumRootContainers(m_ContainerPane, &m_ContainerArrayCount); // FE allocated. BE fills with the number of root containers
|
|
if (result)
|
|
{
|
|
AB_ClosePane (m_ContainerPane);
|
|
m_ContainerPane = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_ContainerArrayCount <= 0)
|
|
{
|
|
m_ContainerArrayCount = 0;
|
|
if (m_ContainerArray != NULL)
|
|
{
|
|
free(m_ContainerArray);
|
|
m_ContainerArray = NULL;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
m_ContainerArray = (AB_ContainerInfo **)
|
|
malloc(sizeof(AB_ContainerInfo *) * m_ContainerArrayCount);
|
|
if (!m_ContainerArray)
|
|
{
|
|
m_ContainerArrayCount = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
result = AB_GetOrderedRootContainers(m_ContainerPane, m_ContainerArray,
|
|
&m_ContainerArrayCount);
|
|
if (result)
|
|
{
|
|
AB_ClosePane (m_ContainerPane);
|
|
m_ContainerPane = NULL;
|
|
free(m_ContainerArray);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
AB_ContainerInfo *
|
|
CNABConnection::FindContainerInfo( LPSTR containerName, LPSTR containerFileName)
|
|
{
|
|
int result;
|
|
AB_ContainerAttribValue *value;
|
|
|
|
// Check the input name...
|
|
if ((!containerName) || (*containerName == '\0'))
|
|
return(NULL);
|
|
|
|
if ((!containerFileName) || (*containerFileName == '\0'))
|
|
return(NULL);
|
|
|
|
// Check object state for AB...
|
|
if ( (!m_ContainerPane) || (m_ContainerArrayCount <= 0) || (!m_ContainerArray) )
|
|
return(NULL);
|
|
|
|
for (int j=0; j<m_ContainerArrayCount; j++)
|
|
{
|
|
// First check the type for the container...
|
|
result = AB_GetContainerAttribute(m_ContainerArray[j], attribContainerType, &value);
|
|
if (result)
|
|
continue;
|
|
|
|
if (value->u.containerType != AB_PABContainer) // AB_LDAPContainer, AB_MListContainer, a mailing list, AB_PABContainer
|
|
{
|
|
AB_FreeContainerAttribValue(value);
|
|
continue;
|
|
}
|
|
|
|
AB_FreeContainerAttribValue(value);
|
|
|
|
// This is valid! Now get the info!
|
|
result = AB_GetContainerAttribute(m_ContainerArray[j], attribName, &value);
|
|
if (result)
|
|
continue;
|
|
|
|
if ( (!value->u.string) || (!*(value->u.string)) )
|
|
{
|
|
AB_FreeContainerAttribValue(value);
|
|
continue;
|
|
}
|
|
|
|
TRACE("CURRENT NAME IS = %s\n", (char *)value->u.string);
|
|
if (strcmp(containerName, (char *)value->u.string) == 0)
|
|
{
|
|
DIR_Server *dir = AB_GetDirServerForContainer(m_ContainerArray[j]);
|
|
if ( (dir) && (dir->fileName != NULL) && (dir->fileName[0] != '\0') )
|
|
{
|
|
char *fullName;
|
|
|
|
DIR_GetServerFileName(&fullName, dir->fileName);
|
|
if ( (fullName != NULL) && (fullName[0] != '\0') )
|
|
{
|
|
if ( strcmp(fullName, containerFileName) == 0)
|
|
{
|
|
XP_FREE(fullName);
|
|
AB_FreeContainerAttribValue(value);
|
|
return( m_ContainerArray[j] );
|
|
}
|
|
else
|
|
{
|
|
XP_FREE(fullName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AB_FreeContainerAttribValue(value);
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// Various utility functions...
|
|
//
|
|
static LPSTR
|
|
CheckNull(LPSTR inStr)
|
|
{
|
|
static UCHAR str[1];
|
|
|
|
str[0] = '\0';
|
|
if (inStr == NULL)
|
|
return((LPSTR)str);
|
|
else
|
|
return(inStr);
|
|
}
|
|
|
|
static LONG
|
|
WriteTheMemoryBufferToDisk(LPSTR fName, UINT bufSize, LPSTR buf)
|
|
{
|
|
if (!buf)
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
HFILE hFile = _lcreat(fName, 0);
|
|
if (hFile == HFILE_ERROR)
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
UINT writeCount = _lwrite(hFile, buf, bufSize);
|
|
_lclose(hFile);
|
|
|
|
if (writeCount != bufSize)
|
|
{
|
|
_unlink(fName);
|
|
return(-1);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
static LPSTR
|
|
GetTheTempDirectoryOnTheSystem(void)
|
|
{
|
|
static UCHAR retPath[_MAX_PATH];
|
|
|
|
if (getenv("TEMP"))
|
|
{
|
|
lstrcpy((LPSTR) retPath, getenv("TEMP")); // environmental variable
|
|
}
|
|
else if (getenv("TMP"))
|
|
{
|
|
lstrcpy((LPSTR) retPath, getenv("TMP")); // How about this environmental variable?
|
|
}
|
|
else
|
|
{
|
|
GetWindowsDirectory((LPSTR) retPath, sizeof(retPath));
|
|
}
|
|
|
|
return((LPSTR) &(retPath[0]));
|
|
}
|
|
|
|
#ifdef WIN16
|
|
static int ISGetTempFileName(LPCSTR a_pDummyPath, LPCSTR a_pPrefix, UINT a_uUnique, LPSTR a_pResultName)
|
|
{
|
|
#ifdef GetTempFileName // we need the real thing comming up next...
|
|
#undef GetTempFileName
|
|
#endif
|
|
return GetTempFileName(0, a_pPrefix, a_uUnique, a_pResultName);
|
|
}
|
|
#endif
|
|
|
|
static DWORD
|
|
ValidateFile(LPCSTR szFile)
|
|
{
|
|
struct _stat buf;
|
|
int result;
|
|
|
|
result = _stat( szFile, &buf );
|
|
if (result != 0)
|
|
return(1);
|
|
|
|
if (!(buf.st_mode & S_IREAD))
|
|
return(2);
|
|
|
|
return(0);
|
|
}
|
|
|
|
static LONG
|
|
GetTempAttachmentName(LPSTR fName)
|
|
{
|
|
UINT res;
|
|
static UINT uUnique = 1;
|
|
|
|
if (!fName)
|
|
return(-1);
|
|
|
|
LPSTR szTempPath = GetTheTempDirectoryOnTheSystem();
|
|
|
|
TRYAGAIN:
|
|
#ifdef WIN32
|
|
res = GetTempFileName(szTempPath, "MAPI", uUnique++, fName);
|
|
#else
|
|
res = ISGetTempFileName(szTempPath, "MAPI", uUnique++, fName);
|
|
#endif
|
|
|
|
if (ValidateFile(fName) != 1)
|
|
{
|
|
if (uUnique < 32000)
|
|
{
|
|
goto TRYAGAIN;
|
|
}
|
|
else
|
|
{
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Find the default session for Communicator...
|
|
//
|
|
static CNABConnection
|
|
*GetDefaultSession(void)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i < MAX_CON; i++)
|
|
{
|
|
if (nabConnections[i] != NULL)
|
|
{
|
|
if (nabConnections[i]->IsDefault())
|
|
{
|
|
return nabConnections[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// Find an open session slot...
|
|
//
|
|
static LONG
|
|
GetOpenSessionSlot( void )
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i < MAX_CON; i++)
|
|
{
|
|
if (nabConnections[i] == NULL)
|
|
{
|
|
return(i);
|
|
}
|
|
}
|
|
|
|
return(-1);
|
|
}
|
|
|
|
//
|
|
// Returns TRUE if it was reassigned and FALSE if not.
|
|
//
|
|
static BOOL
|
|
TryDefaultReassignment(void)
|
|
{
|
|
int i;
|
|
int loc = -1;
|
|
|
|
// Find any sessions left?
|
|
for (i=0; i < MAX_CON; i++)
|
|
{
|
|
if (nabConnections[i] != NULL)
|
|
{
|
|
loc = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Set default state on the object to true
|
|
if (loc >= 0)
|
|
{
|
|
nabConnections[loc]->SetDefault(TRUE);
|
|
return(TRUE);
|
|
}
|
|
else
|
|
{
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// APISTART - Where it all begins...
|
|
//
|
|
LONG
|
|
ProcessNAB_Open(NAB_OpenType *openPtr)
|
|
{
|
|
CNABConnection *defSession = GetDefaultSession();
|
|
TRACE("MAPI: ProcessNAB_Open()\n");
|
|
|
|
// Reset values...
|
|
openPtr->abConnection = 0;
|
|
openPtr->majorVerNumber = 0;
|
|
openPtr->minorVerNumber = 0;
|
|
|
|
//
|
|
// Make sure only MAX_CONN are allowed...
|
|
//
|
|
LONG slot;
|
|
if ((slot = GetOpenSessionSlot()) == -1)
|
|
{
|
|
return(NAB_MAXCON_EXCEEDED);
|
|
}
|
|
|
|
//
|
|
// Create a new session!
|
|
//
|
|
nabConnections[slot] = new CNABConnection(slot);
|
|
if (!nabConnections[slot])
|
|
{
|
|
return(NAB_MEMORY_FAILURE);
|
|
}
|
|
|
|
// Assign the default session...
|
|
if (defSession == NULL)
|
|
{
|
|
nabConnections[slot]->SetDefault(TRUE);
|
|
}
|
|
|
|
// Set the values the API needs to return...
|
|
openPtr->abConnection = nabConnections[slot]->GetID();
|
|
openPtr->majorVerNumber = NAB_VERSION_MAJOR;
|
|
openPtr->minorVerNumber = NAB_VERSION_MINOR;
|
|
|
|
return(NAB_SUCCESS);
|
|
}
|
|
|
|
LONG
|
|
ProcessNAB_Close(NAB_CloseType *closePtr)
|
|
{
|
|
TRACE("MAPI: ProcessNAB_Close() Connection ID = [%d]\n", closePtr->abConnection);
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (( (closePtr->abConnection-1) >= MAX_CON) || ( (closePtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
CNABConnection *closeSession = nabConnections[(closePtr->abConnection - 1)];
|
|
if (closeSession == NULL)
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
//
|
|
// Decrement the session count, then if this is the last one
|
|
// connected to this session, then kill it...
|
|
//
|
|
closeSession->DecrementSessionCount();
|
|
if (closeSession->GetSessionCount() <= 0)
|
|
{
|
|
//
|
|
// If this was the default session "holder", then we need to
|
|
// assign that task to a new one if it exists, if not, then
|
|
// it is all back to null.
|
|
//
|
|
BOOL needToReassign = closeSession->IsDefault();
|
|
|
|
delete closeSession;
|
|
nabConnections[closePtr->abConnection - 1] = NULL;
|
|
|
|
if (needToReassign)
|
|
{
|
|
TRACE("NAB: ProcessNAB_Close() Need to reassign default\n");
|
|
if (!TryDefaultReassignment())
|
|
{
|
|
if (pNABFrameWnd != NULL)
|
|
{
|
|
pNABFrameWnd->PostMessage(WM_CLOSE);
|
|
pNABFrameWnd = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(NAB_SUCCESS);
|
|
}
|
|
|
|
//
|
|
// Actually process the get address book list request...
|
|
//
|
|
LONG
|
|
ProcessNAB_GetAddressBookList(NAB_GetAddressBookListType *getPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
|
|
TRACE("NAB: ProcessNAB_GetAddressBookList() Connection ID = [%d]\n", getPtr->abConnection);
|
|
|
|
// Reset some values...
|
|
getPtr->abookCount = 0;
|
|
getPtr->blobFileName[0] = '\0';
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((getPtr->abConnection-1) >= MAX_CON) || ((getPtr->abConnection-1) < 0))
|
|
return(NAB_INVALID_CONNID);
|
|
|
|
mySession = nabConnections[(getPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
return(NAB_FAILURE);
|
|
|
|
TRACE("NAB: ProcessNAB_GetAddressBookList() Temp File = [%s]\n", getPtr->blobFileName);
|
|
LPSTR *abookArray;
|
|
LONG realAbookCount = 0;
|
|
int result;
|
|
|
|
if (mySession->RefreshABContainerList ( ) == FALSE)
|
|
return(NAB_FAILURE);
|
|
|
|
if (mySession->m_ContainerArrayCount <= 0)
|
|
return(NAB_SUCCESS);
|
|
|
|
if (!(mySession->m_ContainerArray))
|
|
return(NAB_MEMORY_FAILURE);
|
|
|
|
if (GetTempAttachmentName((LPSTR) getPtr->blobFileName) < 0)
|
|
return(NAB_FILE_ERROR);
|
|
|
|
int j;
|
|
AB_ContainerAttribValue *value;
|
|
LONG currentLocation = 0;
|
|
|
|
abookArray = (LPSTR *) malloc( (size_t) sizeof(LPSTR) * ((mySession->m_ContainerArrayCount * 2) + 1) );
|
|
if (!abookArray)
|
|
return(NAB_MEMORY_FAILURE);
|
|
|
|
for (j=0; j < mySession->m_ContainerArrayCount; j++)
|
|
{
|
|
result = AB_GetContainerAttribute(mySession->m_ContainerArray[j], attribContainerType, &value);
|
|
if (result)
|
|
continue;
|
|
|
|
if (value->u.containerType != AB_PABContainer) // AB_LDAPContainer, AB_MListContainer, a mailing list, AB_PABContainer
|
|
{
|
|
AB_FreeContainerAttribValue(value);
|
|
continue;
|
|
}
|
|
|
|
AB_FreeContainerAttribValue(value);
|
|
|
|
TRACE("THIS IS A PERSONAL ADDRESS BOOK\n");
|
|
result = AB_GetContainerAttribute(mySession->m_ContainerArray[j], attribName, &value);
|
|
if (result)
|
|
continue;
|
|
|
|
TRACE("NAME OF THE VALUE IS = %s\n", (char *)value->u.string);
|
|
abookArray[currentLocation++] = strdup((char *)value->u.string);
|
|
AB_FreeContainerAttribValue(value);
|
|
|
|
// Now get the file name...
|
|
DIR_Server *dir = AB_GetDirServerForContainer(mySession->m_ContainerArray[j]);
|
|
if ( (dir) && (dir->fileName != NULL) && (dir->fileName[0] != '\0') )
|
|
{
|
|
char *fullName;
|
|
DIR_GetServerFileName(&fullName, dir->fileName);
|
|
if ( (fullName != NULL) && (fullName[0] != '\0') )
|
|
{
|
|
abookArray[currentLocation++] = fullName;
|
|
}
|
|
else
|
|
{
|
|
abookArray[currentLocation++] = "";
|
|
}
|
|
}
|
|
else
|
|
abookArray[currentLocation++] = "";
|
|
|
|
++realAbookCount;
|
|
}
|
|
|
|
abookArray[currentLocation] = NULL;
|
|
|
|
// Create the string sequence
|
|
NSstringSeq strSeq = NSStrSeqNew(abookArray);
|
|
|
|
// Now just cleanup the array....
|
|
for (int i=0; i<currentLocation; i++)
|
|
{
|
|
if ((abookArray[i] != NULL) && (*(abookArray[i]) != '\0'))
|
|
free(abookArray[i]);
|
|
}
|
|
|
|
free(abookArray);
|
|
|
|
if (!strSeq)
|
|
return(NAB_MEMORY_FAILURE);
|
|
|
|
// Now write the blob to disk and move on...
|
|
if (WriteTheMemoryBufferToDisk((LPSTR) getPtr->blobFileName,
|
|
(UINT) NSStrSeqSize(strSeq), strSeq) != 0)
|
|
{
|
|
NSStrSeqDelete(strSeq);
|
|
return(NAB_MEMORY_FAILURE);
|
|
}
|
|
|
|
NSStrSeqDelete(strSeq);
|
|
getPtr->abookCount = realAbookCount;
|
|
return(NAB_SUCCESS);
|
|
}
|
|
|
|
//
|
|
// Get the default address book type...
|
|
//
|
|
LONG
|
|
ProcessNAB_GetDefaultAddressBook(NAB_GetDefaultAddressBookType *getPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_GetDefaultAddressBook() Connection ID = [%d]\n", getPtr->abConnection);
|
|
|
|
// Reset some values...
|
|
getPtr->abookDesc[0] = '\0';
|
|
getPtr->abookFileName[0] = '\0';
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((getPtr->abConnection-1) >= MAX_CON) || ((getPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(getPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
return(NAB_FAILURE);
|
|
|
|
int j;
|
|
int result;
|
|
AB_ContainerAttribValue *value;
|
|
|
|
if (mySession->RefreshABContainerList ( ) == FALSE)
|
|
return(NAB_FAILURE);
|
|
|
|
if (mySession->m_ContainerArrayCount <= 0)
|
|
return(NAB_SUCCESS);
|
|
|
|
if (!(mySession->m_ContainerArray))
|
|
return(NAB_MEMORY_FAILURE);
|
|
|
|
for (j=0; j < mySession->m_ContainerArrayCount; j++)
|
|
{
|
|
result = AB_GetContainerAttribute(mySession->m_ContainerArray[j], attribContainerType, &value);
|
|
if (result)
|
|
continue;
|
|
|
|
if (value->u.containerType != AB_PABContainer) // AB_LDAPContainer, AB_MListContainer, a mailing list, AB_PABContainer
|
|
{
|
|
AB_FreeContainerAttribValue(value);
|
|
continue;
|
|
}
|
|
|
|
AB_FreeContainerAttribValue(value);
|
|
|
|
TRACE("THIS IS A PERSONAL ADDRESS BOOK\n");
|
|
result = AB_GetContainerAttribute(mySession->m_ContainerArray[j], attribName, &value);
|
|
if (result)
|
|
continue;
|
|
|
|
getPtr->defaultFound = TRUE;
|
|
TRACE("NAME OF THE DEFAULT IS = %s\n", (char *)value->u.string);
|
|
lstrcpy((LPSTR) getPtr->abookDesc, (char *)value->u.string);
|
|
|
|
// Now get the file name...
|
|
DIR_Server *dir = AB_GetDirServerForContainer(mySession->m_ContainerArray[j]);
|
|
if (dir)
|
|
{
|
|
char *fullName;
|
|
DIR_GetServerFileName(&fullName, dir->fileName);
|
|
if ( (fullName != NULL) && (fullName[0] != '\0') )
|
|
{
|
|
lstrcpy((LPSTR) getPtr->abookFileName, fullName);
|
|
XP_FREE(fullName);
|
|
}
|
|
}
|
|
|
|
AB_FreeContainerAttribValue(value);
|
|
break;
|
|
}
|
|
|
|
if (getPtr->defaultFound)
|
|
return(NAB_SUCCESS);
|
|
else
|
|
return(NAB_NOT_FOUND);
|
|
}
|
|
|
|
NAB_CreatePersonalAddressBookType *createPtr = NULL;
|
|
|
|
int
|
|
MyCallbackForCreateAddressBook(
|
|
DIR_Server *server, /* BE will create a DIR_Server and pass it here or pass in an existing DIR_Server if AB_PropertiesCmd */
|
|
MWContext *context,
|
|
MSG_Pane *srcPane, /* the pane that caused this call back */
|
|
XP_Bool newDirectory) /* BE will set this argument to TRUE if the FE is showing a new DIR_Server and FALSE otherwise */
|
|
{
|
|
int result;
|
|
if (!createPtr)
|
|
return(1);
|
|
|
|
// Set the description in the DIR_Server structure...
|
|
server->description = strdup(createPtr->abookName);
|
|
|
|
result = AB_UpdateDIRServerForContainerPane(srcPane, server);
|
|
|
|
if ( (server->fileName != NULL) && (server->fileName[0] != '\0') )
|
|
{
|
|
char *fullName;
|
|
DIR_GetServerFileName(&fullName, server->fileName);
|
|
|
|
if ( (fullName != NULL) && (fullName[0] != '\0') )
|
|
{
|
|
lstrcpy((LPSTR) createPtr->abookFileName, fullName);
|
|
}
|
|
else
|
|
{
|
|
lstrcpy((LPSTR) createPtr->abookFileName, (LPSTR)server->fileName);
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
//
|
|
// Create the address book...
|
|
//
|
|
LONG
|
|
ProcessNAB_CreatePersonalAddressBook(NAB_CreatePersonalAddressBookType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_CreatePersonalAddressBook() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
TRACE("NAB: Address Book Name [%s]\n", shmPtr->abookName);
|
|
|
|
// Reset some values...
|
|
shmPtr->abookFileName[0] = '\0';
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
int result;
|
|
createPtr = shmPtr;
|
|
result = AB_SetShowPropertySheetForDirFunc(mySession->m_ContainerPane,
|
|
MyCallbackForCreateAddressBook);
|
|
if (result)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
// Create the address book!
|
|
result = AB_CommandAB2(mySession->m_ContainerPane, AB_NewAddressBook, 0, 0);
|
|
if (result)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
else
|
|
{
|
|
AB_InitializeContainerPane(mySession->m_ContainerPane);
|
|
return(NAB_SUCCESS);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save the address book to HTML...
|
|
//
|
|
LONG
|
|
ProcessNAB_SaveAddressBookToHTML(NAB_SaveAddressBookToHTMLType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_SaveAddressBookToHTML() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
TRACE("NAB: HTML File Name [%s]\n", shmPtr->HTMLFileName);
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("ADDRESS BOOK NAME : [%s]\n", shmPtr->abookName);
|
|
TRACE("HTML FILE NAME : [%s]\n", shmPtr->abookFileName);
|
|
LONG result;
|
|
MSG_Pane *addressBookPane; // Container info for a particular addr book
|
|
LONG currentLocation;
|
|
|
|
TRACE("HTML FILENAME: [%s]\n", shmPtr->HTMLFileName);
|
|
if ( ValidateFile(shmPtr->HTMLFileName) != 1)
|
|
return(NAB_FILE_ERROR);
|
|
|
|
if (! OpenNABAPIHTMLFile(shmPtr->HTMLFileName, shmPtr->abookName) )
|
|
return(NAB_FILE_ERROR);
|
|
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
{
|
|
(void) CloseNABAPIHTMLFile();
|
|
unlink(shmPtr->abookFileName);
|
|
return(NAB_INVALID_ABOOK);
|
|
}
|
|
|
|
result = AB_CreateABPane(&addressBookPane, theApp.m_pAddressContext, WFE_MSGGetMaster());
|
|
if (result)
|
|
{
|
|
(void) CloseNABAPIHTMLFile();
|
|
unlink(shmPtr->abookFileName);
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
result = AB_InitializeABPane(addressBookPane, conInfo);
|
|
if (result)
|
|
{
|
|
(void) CloseNABAPIHTMLFile();
|
|
AB_ClosePane(addressBookPane);
|
|
unlink(shmPtr->abookFileName);
|
|
return(NAB_INVALID_ABOOK);
|
|
}
|
|
|
|
LONG lineCount = MSG_GetNumLines(addressBookPane);
|
|
currentLocation = 0;
|
|
|
|
while ( currentLocation < lineCount )
|
|
{
|
|
(void) DumpHTMLTableLineForUser(addressBookPane, currentLocation);
|
|
// Increment for next call...
|
|
currentLocation++;
|
|
}
|
|
|
|
AB_ClosePane(addressBookPane);
|
|
if (CloseNABAPIHTMLFile())
|
|
{
|
|
return(NAB_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
unlink(shmPtr->abookFileName);
|
|
return(NAB_FAILURE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Import LDIF file...
|
|
//
|
|
LONG
|
|
ProcessNAB_ImportLDIFFile(NAB_ImportLDIFFileType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_ImportLDIFFile() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
TRACE("NAB: LDIF File to Import [%s]\n", shmPtr->LDIFFileName);
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("LDIF Import File: [%s]\n", shmPtr->LDIFFileName);
|
|
if ( ValidateFile(shmPtr->LDIFFileName) != 0)
|
|
{
|
|
return(NAB_FILE_NOT_FOUND);
|
|
}
|
|
|
|
TRACE("SPECIFY ADDRESS BOOK NAME: [%s]\n", shmPtr->abookName);
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
return(NAB_INVALID_ABOOK);
|
|
|
|
char *tPtr = shmPtr->LDIFFileName;
|
|
int failed = AB_ImportData(conInfo, tPtr, 0, AB_Filename);
|
|
if (!failed)
|
|
{
|
|
if (shmPtr->deleteImportFile)
|
|
{
|
|
unlink(shmPtr->abookFileName);
|
|
}
|
|
return(NAB_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Export LDIF file...
|
|
//
|
|
LONG
|
|
ProcessNAB_ExportLDIFFile(NAB_ExportLDIFFileType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_ExportLDIFFile() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
TRACE("NAB: LDIF File Name [%s]\n", shmPtr->LDIFFileName);
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("ADDRESS BOOK FILENAME: [%s]\n", shmPtr->abookFileName);
|
|
if ( ValidateFile(shmPtr->abookFileName) != 1)
|
|
{
|
|
return(NAB_FILE_ERROR);
|
|
}
|
|
|
|
TRACE("SPECIFY ADDRESS BOOK NAME: [%s]\n", shmPtr->abookName);
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
return(NAB_INVALID_ABOOK);
|
|
|
|
char *tPtr = shmPtr->LDIFFileName;
|
|
int failed = AB_ExportData(conInfo, &(tPtr), 0, AB_Filename);
|
|
if (!failed)
|
|
{
|
|
return(NAB_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
return(NAB_FILE_ERROR);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get first address book entry...
|
|
//
|
|
LONG
|
|
ProcessNAB_GetFirstAddressBookEntry(NAB_GetFirstAddressBookEntryType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_GetFirstAddressBookEntry() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
|
|
// Reset some values...
|
|
shmPtr->userID = 0;
|
|
shmPtr->updateTime = 0;
|
|
shmPtr->userInfo[0] = '\0';
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("ADDRESS BOOK NAME : [%s]\n", shmPtr->abookName);
|
|
TRACE("ADDRESS BOOK FILENAME: [%s]\n", shmPtr->abookFileName);
|
|
NABUserID userID;
|
|
NABUpdateTime updtTime;
|
|
LONG result;
|
|
|
|
if (mySession->m_AddressBookPane != NULL)
|
|
{
|
|
AB_ClosePane(mySession->m_AddressBookPane);
|
|
mySession->m_AddressBookPane = NULL;
|
|
}
|
|
|
|
TRACE("RICHIE-TODO: GOTTA GET UPDATE TIME\n");
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
return(NAB_INVALID_ABOOK);
|
|
|
|
result = AB_CreateABPane(&(mySession->m_AddressBookPane), theApp.m_pAddressContext, WFE_MSGGetMaster());
|
|
if (result)
|
|
return(NAB_FAILURE);
|
|
|
|
result = AB_InitializeABPane(mySession->m_AddressBookPane, conInfo);
|
|
if (result)
|
|
return(NAB_FAILURE);
|
|
|
|
LONG lineCount = MSG_GetNumLines(mySession->m_AddressBookPane);
|
|
mySession->SetNameIndex( 0 );
|
|
mySession->SetNameTotalCount( lineCount );
|
|
|
|
BOOL found = FALSE;
|
|
|
|
while ( mySession->GetNameIndex() < mySession->GetNameTotalCount() )
|
|
{
|
|
found = GetLDIFLineForUser(mySession->m_AddressBookPane,
|
|
mySession->GetNameIndex(),
|
|
shmPtr->userInfo, &userID,
|
|
&updtTime);
|
|
// Increment for next call...
|
|
mySession->IncrementNameIndex();
|
|
|
|
if (found)
|
|
break;
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
shmPtr->userID = userID;
|
|
shmPtr->updateTime = updtTime;
|
|
return(NAB_SUCCESS);
|
|
}
|
|
else
|
|
return(NAB_NOT_FOUND);
|
|
}
|
|
|
|
//
|
|
// Get next address book entry...
|
|
//
|
|
LONG
|
|
ProcessNAB_GetNextAddressBookEntry(NAB_GetNextAddressBookEntryType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_GetNextAddressBookEntry() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
|
|
// Reset some values...
|
|
shmPtr->userID = 0;
|
|
shmPtr->updateTime = 0;
|
|
shmPtr->userInfo[0] = '\0';
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("RICHIE-TODO: GOTTA GET UPDATE TIME\n");
|
|
NABUserID userID;
|
|
NABUpdateTime updtTime;
|
|
|
|
if (mySession->m_AddressBookPane == NULL)
|
|
return(NAB_INVALID_ABOOK);
|
|
|
|
LONG myIndex = mySession->GetNameIndex();
|
|
if ( myIndex >= mySession->GetNameTotalCount() )
|
|
{
|
|
if (mySession->m_AddressBookPane != NULL)
|
|
{
|
|
AB_ClosePane(mySession->m_AddressBookPane);
|
|
mySession->m_AddressBookPane = NULL;
|
|
}
|
|
|
|
return(NAB_NOT_FOUND);
|
|
}
|
|
|
|
BOOL found = FALSE;
|
|
while ( mySession->GetNameIndex() < mySession->GetNameTotalCount() )
|
|
{
|
|
found = GetLDIFLineForUser(mySession->m_AddressBookPane,
|
|
mySession->GetNameIndex(),
|
|
shmPtr->userInfo, &userID,
|
|
&updtTime);
|
|
// Increment for next call...
|
|
mySession->IncrementNameIndex();
|
|
|
|
if (found)
|
|
break;
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
shmPtr->userID = userID;
|
|
shmPtr->updateTime = updtTime;
|
|
return(NAB_SUCCESS);
|
|
}
|
|
else
|
|
return(NAB_NOT_FOUND);
|
|
}
|
|
|
|
//
|
|
// Find a particular address book entry...
|
|
//
|
|
LONG
|
|
ProcessNAB_FindAddressBookEntry(NAB_FindAddressBookEntryType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_FindAddressBookEntry() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
|
|
// Reset some values...
|
|
shmPtr->userInfo[0] = '\0';
|
|
shmPtr->updateTime = 0;
|
|
|
|
if (shmPtr->ldifSearchAttribute[0] != '\0')
|
|
shmPtr->userID = 0;
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
int result;
|
|
AB_ContainerAttribValue *value;
|
|
BOOL found = FALSE;
|
|
|
|
// Check object state for AB...
|
|
if ( (!(mySession->m_ContainerPane)) ||
|
|
((mySession->m_ContainerArrayCount) <= 0) ||
|
|
(!(mySession->m_ContainerArray)) )
|
|
return(NAB_INVALID_ABOOK);
|
|
|
|
// Now either search a specific address book, OR ALL ADDRESS BOOKS!
|
|
if (shmPtr->abookName[0] == '\0')
|
|
{
|
|
for (int j=0; j<mySession->m_ContainerArrayCount; j++)
|
|
{
|
|
// First check the type for the container...
|
|
result = AB_GetContainerAttribute(mySession->m_ContainerArray[j], attribContainerType, &value);
|
|
if (result)
|
|
continue;
|
|
|
|
if (value->u.containerType != AB_PABContainer) // AB_LDAPContainer, AB_MListContainer, a mailing list, AB_PABContainer
|
|
{
|
|
AB_FreeContainerAttribValue(value);
|
|
continue;
|
|
}
|
|
AB_FreeContainerAttribValue(value);
|
|
|
|
if (SearchABForAttrib( mySession->m_ContainerArray[j],
|
|
shmPtr->ldifSearchAttribute,
|
|
shmPtr->userInfo,
|
|
&(shmPtr->userID),
|
|
&(shmPtr->updateTime)) )
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE("SEARCHING ADDRESS BOOK NAME : [%s]\n", shmPtr->abookName);
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
return(NAB_INVALID_ABOOK);
|
|
|
|
if (SearchABForAttrib( conInfo, shmPtr->ldifSearchAttribute,
|
|
shmPtr->userInfo, &(shmPtr->userID), &(shmPtr->updateTime)) )
|
|
{
|
|
found = TRUE;
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
return(NAB_SUCCESS);
|
|
else
|
|
return(NAB_NOT_FOUND);
|
|
/*
|
|
NAB_FAILURE - General failure performing the query
|
|
NAB_NOT_FOUND - The requested entry was not found
|
|
NAB_NOT_OPEN - This will be returned when a call is made to the API without NAB_Open() being called first.
|
|
NAB_INVALID_ABOOK - Address book specified is invalid
|
|
NAB_INVALID_CONNID - Invalid connection ID
|
|
NAB_MULTIPLE_USERS_FOUND - More than one person found with current search criteria
|
|
NAB_INVALID_SEARCH_ATTRIB - Invalid search criteria
|
|
*/
|
|
}
|
|
|
|
//
|
|
// Insert an address book entry...
|
|
//
|
|
LONG
|
|
ProcessNAB_InsertAddressBookEntry(NAB_InsertAddressBookEntryType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_InsertAddressBookEntry() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
|
|
// Check for SOME input
|
|
if (shmPtr->userInfo[0] == '\0')
|
|
return NAB_FAILURE;
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("ADDRESS BOOK NAME : [%s]\n", shmPtr->abookName);
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
{
|
|
return(NAB_INVALID_ABOOK);
|
|
}
|
|
|
|
ABID userID;
|
|
|
|
TRACE("INSERT THE ADDRESS BOOK ENTRY: [%s]\n", shmPtr->userInfo);
|
|
NABError result = InsertEntryToAB(conInfo, shmPtr->userInfo,
|
|
FALSE, &userID);
|
|
shmPtr->userID = userID;
|
|
return(result);
|
|
}
|
|
|
|
//
|
|
// Updating an address book entry...
|
|
//
|
|
LONG
|
|
ProcessNAB_UpdateAddressBookEntry(NAB_UpdateAddressBookEntryType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_UpdateAddressBookEntry() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("ADDRESS BOOK NAME : [%s]\n", shmPtr->abookName);
|
|
TRACE("ADDRESS BOOK FILENAME: [%s]\n", shmPtr->abookFileName);
|
|
TRACE("UPDATING ADDRESS BOOK ENTRY: [%d]\n", shmPtr->userID);
|
|
LONG result;
|
|
MSG_Pane *addressBookPane; // Container info for a particular addr book
|
|
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
{
|
|
return(NAB_INVALID_ABOOK);
|
|
}
|
|
|
|
result = AB_CreateABPane(&addressBookPane, theApp.m_pAddressContext, WFE_MSGGetMaster());
|
|
if (result)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
result = AB_InitializeABPane(addressBookPane, conInfo);
|
|
if (result)
|
|
{
|
|
AB_ClosePane(addressBookPane);
|
|
return(NAB_INVALID_ABOOK);
|
|
}
|
|
|
|
DWORD lineCount = MSG_GetNumLines(addressBookPane);
|
|
MSG_ViewIndex currentLocation = 0;
|
|
ABID id;
|
|
BOOL found = FALSE;
|
|
|
|
while ( currentLocation < lineCount )
|
|
{
|
|
result = AB_GetABIDForIndex(addressBookPane, currentLocation, &id);
|
|
if (result)
|
|
continue;
|
|
|
|
if (id == (ABID) shmPtr->userID)
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
|
|
// Increment for next call...
|
|
currentLocation++;
|
|
}
|
|
|
|
if (!found)
|
|
return(NAB_NOT_FOUND);
|
|
|
|
result = InsertEntryToAB(conInfo, shmPtr->userInfo, TRUE, &id);
|
|
return(result);
|
|
}
|
|
|
|
//
|
|
// Deleting an address book entry...
|
|
//
|
|
LONG
|
|
ProcessNAB_DeleteAddressBookEntry(NAB_DeleteAddressBookEntryType *shmPtr)
|
|
{
|
|
CNABConnection *mySession;
|
|
TRACE("NAB: ProcessNAB_DeleteAddressBookEntry() Connection ID = [%d]\n", shmPtr->abConnection);
|
|
|
|
//
|
|
// Verify the session handle...
|
|
//
|
|
if (((shmPtr->abConnection-1) >= MAX_CON) || ((shmPtr->abConnection-1) < 0))
|
|
{
|
|
return(NAB_INVALID_CONNID);
|
|
}
|
|
|
|
mySession = nabConnections[(shmPtr->abConnection - 1)];
|
|
if (mySession == NULL)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
TRACE("ADDRESS BOOK NAME : [%s]\n", shmPtr->abookName);
|
|
TRACE("ADDRESS BOOK FILENAME: [%s]\n", shmPtr->abookFileName);
|
|
TRACE("DELETING ADDRESS BOOK ENTRY: [%d]\n", shmPtr->userID);
|
|
LONG result;
|
|
MSG_Pane *addressBookPane; // Container info for a particular addr book
|
|
|
|
AB_ContainerInfo *conInfo = mySession->FindContainerInfo(shmPtr->abookName,
|
|
shmPtr->abookFileName);
|
|
if (!conInfo)
|
|
{
|
|
return(NAB_INVALID_ABOOK);
|
|
}
|
|
|
|
result = AB_CreateABPane(&addressBookPane, theApp.m_pAddressContext, WFE_MSGGetMaster());
|
|
if (result)
|
|
{
|
|
return(NAB_FAILURE);
|
|
}
|
|
|
|
result = AB_InitializeABPane(addressBookPane, conInfo);
|
|
if (result)
|
|
{
|
|
AB_ClosePane(addressBookPane);
|
|
return(NAB_INVALID_ABOOK);
|
|
}
|
|
|
|
DWORD lineCount = MSG_GetNumLines(addressBookPane);
|
|
MSG_ViewIndex currentLocation = 0;
|
|
ABID id;
|
|
BOOL found = FALSE;
|
|
|
|
while ( currentLocation < lineCount )
|
|
{
|
|
result = AB_GetABIDForIndex(addressBookPane, currentLocation, &id);
|
|
if (result)
|
|
continue;
|
|
|
|
if (id == (ABID) shmPtr->userID)
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
|
|
// Increment for next call...
|
|
currentLocation++;
|
|
}
|
|
|
|
if (!found)
|
|
return(NAB_NOT_FOUND);
|
|
|
|
MSG_ViewIndex indices[1];
|
|
|
|
indices[0] = currentLocation;
|
|
if (AB_CommandAB2( addressBookPane, AB_DeleteCmd, indices, 1) )
|
|
{
|
|
AB_ClosePane(addressBookPane);
|
|
return(NAB_FAILURE);
|
|
}
|
|
else
|
|
{
|
|
AB_ClosePane(addressBookPane);
|
|
return(NAB_SUCCESS);
|
|
}
|
|
}
|