Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-12 14:37:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5a5e5425cf
gecko-dev/cmd/winfe/abhook.cpp
spider cb94dae31e NORMANDY_DDAY merge...
1998-06-25 05:50:45 +00:00

1875 lines
47 KiB
C++
Raw Blame History

/* -*- 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);
}
}
Reference in New Issue View Git Blame Copy Permalink