#include "pch.hxx"
#include <imnact.h>
#include <acctimp.h>
#include <dllmain.h>
#include <resource.h>
#include "CommNews.h"
#include "newimp.h"
#include "ids.h"

ASSERTDATA

INT_PTR CALLBACK SelectServerDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
const static char c_szNescapeMapFile[]  = "netscape-newsrc-map-file";
#define MEMCHUNK    512

CCommNewsAcctImport::CCommNewsAcctImport()
    {
    m_cRef = 1;
    m_fIni = FALSE;
    *m_szIni = 0;
    m_cInfo = 0;
    m_rgInfo = NULL;
    m_szSubList = NULL;
    m_rgServ = NULL;
    m_nNumServ = 0;
    }

CCommNewsAcctImport::~CCommNewsAcctImport()
{
    NEWSSERVERS *pTempServ  = m_rgServ;
    NEWSSERVERS *pNextServ  = pTempServ;

    if (m_rgInfo != NULL)
        MemFree(m_rgInfo);
    
    if(m_szSubList != NULL)
        MemFree(m_szSubList);
    
    while(pTempServ)
    {
        pNextServ  = pTempServ->pNext;
        delete(pTempServ);
        pTempServ = pNextServ;
    }
}

STDMETHODIMP CCommNewsAcctImport::QueryInterface(REFIID riid, LPVOID *ppv)
    {
    if (ppv == NULL)
        return(E_INVALIDARG);

    *ppv = NULL;

    if (IID_IUnknown == riid || riid == IID_IAccountImport)
		*ppv = (IAccountImport *)this;
    else if (IID_IAccountImport2 == riid)
        *ppv = (IAccountImport2 *)this;
    else
        return(E_NOINTERFACE);

    ((LPUNKNOWN)*ppv)->AddRef();

    return(S_OK);
    }

STDMETHODIMP_(ULONG) CCommNewsAcctImport::AddRef()
    {
    return(++m_cRef);
    }

STDMETHODIMP_(ULONG) CCommNewsAcctImport::Release()
    {
    if (--m_cRef == 0)
        {
        delete this;
        return(0);
        }

    return(m_cRef);
    }

const static char c_szRegNscp[] = "Software\\Netscape\\Netscape Navigator\\Users";
const static char c_szRegMail[] = "Mail";
const static char c_szRegUser[] = "User";
const static char c_szRegDirRoot[] = "DirRoot";

HRESULT STDMETHODCALLTYPE CCommNewsAcctImport::AutoDetect(DWORD *pcAcct, DWORD dwFlags)
    {
    HRESULT hr;
    DWORD   dwNumSubKeys    =   0;
    DWORD   dwIndex         =   0;
    HRESULT hrUser          =   E_FAIL;
    DWORD   cb              =   MAX_PATH;
    char    szUserName[MAX_PATH];
    char    szUserProfile[MAX_PATH];
    char    szUserPrefs[2][NEWSUSERCOLS], szExpanded[MAX_PATH], *psz;
    HKEY    hkey, 
            hkeyUsers;
    char    szPop[MAX_PATH];
    DWORD   dwType;
    long    lRetVal         =   0;


    Assert(m_cInfo == 0);
    if (pcAcct == NULL)
        return(E_INVALIDARG);

    hr = S_FALSE;
    *pcAcct = 0;

    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegNscp, 0, KEY_ALL_ACCESS, &hkey))
        {
//          TODO : Fill up the m_rgInfo array with the info of all 
//          the users who have accounts in Communicator.
            if(ERROR_SUCCESS == RegQueryInfoKey( hkey, NULL, NULL, 0, &dwNumSubKeys, 
                                  NULL, NULL, NULL, NULL, NULL, NULL, NULL ) && (dwNumSubKeys > 0))
            {
                if (!MemAlloc((void **)&m_rgInfo, dwNumSubKeys * sizeof(COMMNEWSACCTINFO)))
                {
                    hr = E_OUTOFMEMORY;
                    goto done;
                }

                while(ERROR_SUCCESS == RegEnumKeyEx(hkey, dwIndex, szUserName, &cb, NULL, NULL, NULL, NULL))
                {
                    if(ERROR_SUCCESS == RegOpenKeyEx(hkey, szUserName, 0, KEY_ALL_ACCESS, &hkeyUsers))
                    {
                        cb = sizeof(szUserProfile);
                        if(ERROR_SUCCESS == (lRetVal = RegQueryValueEx(hkeyUsers, c_szRegDirRoot, NULL, &dwType, (LPBYTE)szUserProfile, &cb )))
                        {
                            if (REG_EXPAND_SZ == dwType)
                            {
                                ExpandEnvironmentStrings(szUserProfile, szExpanded, ARRAYSIZE(szExpanded));
                                psz = szExpanded;
                            }
                            else 
                                psz = szUserProfile;
                            
                            //save vals into the m_rgInfo structure
                            hrUser = GetUserPrefs(psz, szUserPrefs, 1, NULL);
                            if(!FAILED(hrUser))
                            {
                                hrUser = IsValidUser(psz);
                                if(!FAILED(hrUser))
                                {
                                    m_rgInfo[m_cInfo].dwCookie = m_cInfo;
                                    StrCpyN(m_rgInfo[m_cInfo].szUserPath, psz, ARRAYSIZE(m_rgInfo[m_cInfo].szUserPath));
                                    StrCpyN(m_rgInfo[m_cInfo].szDisplay, szUserName, ARRAYSIZE(m_rgInfo[m_cInfo].szDisplay));
                                    m_cInfo++;
                                }
                            }
                        }
                        RegCloseKey(hkeyUsers);
                    }
                    dwIndex++;
                    if(dwIndex == dwNumSubKeys)
                        hr = S_OK;
                }
            }
        }

    if (hr == S_OK)
    {
        *pcAcct = m_cInfo;
    }

done:
//      Close the reg key now....
        RegCloseKey(hkey);

    return(hr);
    }

typedef struct tagSELSERVER
{
    NEWSSERVERS *prgList;
    DWORD       *dwSelServ;

}SELSERVER;

// This function is called after we select a user profile (in case more than one is present)
// but before the 'GetSettings' finction is called. In case this profile has more than one 
// servers configured, we need to display a dialog box asking the user to select a server 
// account to import.

HRESULT STDMETHODCALLTYPE CCommNewsAcctImport::InitializeImport(HWND hwnd, DWORD_PTR dwCookie)
{
    HRESULT hr;
    SELSERVER ss;
    int nRetVal = 0;

    GetNumAccounts(dwCookie);

    if(m_rgServ == NULL)
    {
        m_dwSelServ = 0;
        return S_OK;
    }
    ss.prgList = m_rgServ;
    ss.dwSelServ = &m_dwSelServ;

    if(m_nNumServ > 1)
    {
        nRetVal = (int) DialogBoxParam(g_hInstRes, MAKEINTRESOURCE(IDD_PAGE_NEWSSERVERSELECT), hwnd, SelectServerDlgProc, (LPARAM)&ss);
        if (nRetVal == IDCANCEL)
            hr = E_FAIL;
        else if (nRetVal == IDOK)
            hr = S_OK;
        else
            hr = E_FAIL;
    }
    else
    {
        m_dwSelServ = 0;
        hr = S_OK;
    }
    return hr;
}

INT_PTR CALLBACK SelectServerDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    HWND hwndT;
    WORD id;
    DWORD iSubKey, cb;
    char sz[MAX_PATH];
    SELSERVER   *pss;
    NEWSSERVERS *pTempServ = NULL;
    int index;
    
    switch (msg)
    {
    case WM_INITDIALOG:
        Assert(lParam != NULL);
        pss = (SELSERVER *)lParam;
        SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pss);
        
        hwndT = GetDlgItem(hwnd, IDC_ACCTLIST);
        
        // fill list
        pTempServ = pss->prgList;
        while(pTempServ != NULL)
        {
            if(lstrlen(pTempServ->szServerName) && lstrlen(pTempServ->szFilePath))
            {
                SendMessage(hwndT, LB_ADDSTRING, 0, (LPARAM)pTempServ->szServerName);
            }
            pTempServ = pTempServ->pNext;
        }
        
        SendMessage(hwndT, LB_SETCURSEL, 0, 0);
        return(TRUE);
        
    case WM_COMMAND:
        id = LOWORD(wParam);
        switch (id)
        {
        case IDOK:
            pss = (SELSERVER *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
            Assert(pss != NULL);
            
            hwndT = GetDlgItem(hwnd, IDC_ACCTLIST);
            index = (int) SendMessage(hwndT, LB_GETCURSEL, 0, 0);
            Assert(index >= 0);
            *(pss->dwSelServ) = (long)index;
            
            // fall through
            
        case IDCANCEL:
            EndDialog(hwnd, id);
            return(TRUE);
        }
        break;
    }
    
    return(FALSE);
}

HRESULT STDMETHODCALLTYPE CCommNewsAcctImport::EnumerateAccounts(IEnumIMPACCOUNTS **ppEnum)
    {
    CEnumCOMMNEWSACCT *penum;
    HRESULT hr;

    if (ppEnum == NULL)
        return(E_INVALIDARG);

    *ppEnum = NULL;

    if (m_cInfo == 0)
        return(S_FALSE);
    Assert(m_rgInfo != NULL);

    penum = new CEnumCOMMNEWSACCT;
    if (penum == NULL)
        return(E_OUTOFMEMORY);

    hr = penum->Init(m_rgInfo, m_cInfo);
    if (FAILED(hr))
        {
        penum->Release();
        penum = NULL;
        }

    *ppEnum = penum;

    return(hr);
    }

HRESULT CCommNewsAcctImport::IsValidUser(char *pszFilePath)
{
    char szNewsPath[MAX_PATH * 2];    
    HANDLE hFatFile = NULL;
    DWORD dwFatFileSize = 0;
    HRESULT hr = E_FAIL;

    StrCpyN(szNewsPath, pszFilePath, ARRAYSIZE(szNewsPath));
    StrCatBuff(szNewsPath, "\\News\\fat", ARRAYSIZE(szNewsPath));

    hFatFile = CreateFile(szNewsPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL); 
    
    if(INVALID_HANDLE_VALUE == hFatFile)
        return hr;
    
    dwFatFileSize = GetFileSize(hFatFile, NULL);

    if(dwFatFileSize > 0)
        hr = S_OK;

    CloseHandle(hFatFile);

    return hr;
}

// The following two functions have been added to handle the importing of subscribed newsgroups

HRESULT CCommNewsAcctImport::GetNumAccounts(DWORD_PTR dwCookie)
{
    COMMNEWSACCTINFO    *pinfo;
    NEWSSERVERS         *pTempServ = NULL;
    NEWSSERVERS         *pPrevServ = NULL;
    HRESULT hr = S_FALSE;
    char szNewsPath[MAX_PATH * 2];
    char szLineHolder[MAX_PATH * 2];
    HANDLE hFatFile = NULL;
    HANDLE hFatFileMap = NULL;
    BYTE *pFatViewBegin  = NULL,
         *pFatViewCurr   = NULL,
         *pFatViewEnd    = NULL;
    char *pParse = NULL;
    char *pServName = NULL;
    DWORD dwFatFileSize = 0;
    UINT uLine  =   0;
    char cPlaceHldr = 1;
    int nCount = 0;

    Assert(((int)dwCookie) >= 0 && dwCookie < (DWORD)m_cInfo);
    pinfo = &m_rgInfo[dwCookie];
    Assert(pinfo->dwCookie == dwCookie);

    StrCpyN(szNewsPath, pinfo->szUserPath, ARRAYSIZE(szNewsPath));
    StrCatBuff(szNewsPath, "\\News\\fat", ARRAYSIZE(szNewsPath));

    hFatFile = CreateFile(szNewsPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL); 
    
    if(INVALID_HANDLE_VALUE == hFatFile)
        return hr;
    
    dwFatFileSize = GetFileSize(hFatFile, NULL);
    
    hFatFileMap = CreateFileMapping(hFatFile, NULL, PAGE_READONLY, 0, 0, NULL);

    if(NULL == hFatFileMap)
    {
        CloseHandle(hFatFile);
        return hr;
    }

    pFatViewBegin = (BYTE*)MapViewOfFile(hFatFileMap, FILE_MAP_READ, 0, 0, 0);

    if(pFatViewBegin  == NULL)
    {
       CloseHandle(hFatFileMap);
       CloseHandle(hFatFile);
       return hr;
    }

    pFatViewCurr = pFatViewBegin;
    pFatViewEnd  = pFatViewCurr + dwFatFileSize;

    pTempServ = m_rgServ;
    while(pTempServ)
    {
        pPrevServ = pTempServ->pNext;
        ZeroMemory(pTempServ, sizeof(NEWSSERVERS));
        pTempServ->pNext = pPrevServ;
        pTempServ = pTempServ->pNext;
    }
    pTempServ = NULL;
    pPrevServ = NULL;

    // We will skip the first line in the "fat" file as it contains a comment.
    // m_szSubList is a null separated list of 
    while(pFatViewCurr < pFatViewEnd)
    {
        uLine = 0;
        while(!((pFatViewCurr[uLine] == 0x0D) && (pFatViewCurr[uLine + 1] == 0x0A)) && (pFatViewCurr + uLine < pFatViewEnd))
            uLine++;

        if(pFatViewCurr + uLine > pFatViewEnd)
            break;

        StrCpyN(szLineHolder, (char*)pFatViewCurr, uLine + 1);
        pServName = szLineHolder;
        pParse = szLineHolder;

        if(!lstrcmp(szLineHolder, c_szNescapeMapFile))
        {
            pFatViewCurr += (uLine + 2);
            nCount = 0;
            continue;
        }

        while((*pServName != '-') && (*pServName != '\0'))
            pServName++;
        pServName++;

        // Go to the first char '9' position
        while((*pParse != '\0') && ((*pParse) != 9))
            pParse++;
        *pParse = '\0'; 
        // pass over what was originally the first char '9' position
        pParse++;

        // Trim the remaining string to the second char '9' position.
        while(pParse[nCount] != '\0')
        {
            if((int)pParse[nCount] == 9)
            {
                pParse[nCount] = '\0';
                break;
            }
            nCount++;
        }
                
        if(0 == pPrevServ)
        {
            if(!m_rgServ)
            {
                m_rgServ = (NEWSSERVERS*)new NEWSSERVERS;
                ZeroMemory((void*)m_rgServ, sizeof(NEWSSERVERS));
            }
            StrCpyN(m_rgServ->szServerName, pServName, ARRAYSIZE(m_rgServ->szServerName));
            StrCpyN(m_rgServ->szFilePath, pParse, ARRAYSIZE(m_rgServ->szFilePath));
            pPrevServ = m_rgServ;
        }
        else
        {
            if(!pPrevServ->pNext)
            {
                pPrevServ->pNext = (NEWSSERVERS*)new NEWSSERVERS;
                ZeroMemory((void*)pPrevServ->pNext, sizeof(NEWSSERVERS));
            }
            StrCpyN(pPrevServ->pNext->szServerName, pServName, ARRAYSIZE(pPrevServ->pNext->szServerName));
            StrCpyN(pPrevServ->pNext->szFilePath, pParse, ARRAYSIZE(pPrevServ->pNext->szFilePath));
            pPrevServ = pPrevServ->pNext;
        }

        pFatViewCurr += (uLine + 2);
        nCount = 0;
    }

    //replace the cPlaceHldr placeholder by nulls.

    hr = S_OK;

    pTempServ = m_rgServ;
    m_nNumServ = 0;
    while(pTempServ != NULL)
    {
        if(lstrlen(pTempServ->szServerName) && lstrlen(pTempServ->szFilePath))
        {
            m_nNumServ += 1;
        }
        pTempServ = pTempServ->pNext;
    }

//  Done: 
    CloseHandle(hFatFileMap);
    CloseHandle(hFatFile);
    UnmapViewOfFile(pFatViewBegin); 
    return hr;
}

HRESULT CCommNewsAcctImport::GetNewsGroup(INewsGroupImport *pImp, DWORD dwReserved) //char *szServerName, char *szAccountName)
{
    HRESULT hr = S_OK;
    HINSTANCE hInstance = NULL;
    char *pListGroups = NULL;
    NEWSSERVERS *pTempServ = NULL;
    NEWSSERVERS *pPrevServ = NULL;
    char        szTempString[NEWSUSERCOLS];
    char        szFilePath[NEWSUSERCOLS];
    int         nReach = 0;

    szFilePath[0] = '\0';
    Assert(m_nNumServ > m_dwSelServ);
    Assert(pImp != NULL);

    pTempServ = m_rgServ;
    for(DWORD nTemp1 = 0; nTemp1 < m_dwSelServ; nTemp1++)
    {
        pTempServ = pTempServ->pNext;
        if(pTempServ == NULL)
            return S_FALSE;
    }
    
    if(!FAILED(GetSubListGroups(pTempServ->szFilePath, &pListGroups)))
    {
        if(!SUCCEEDED(pImp->ImportSubList(pListGroups)))
            hr = S_FALSE;
    }
    if(pListGroups != NULL)
        MemFree(pListGroups);

    return hr;
}

HRESULT CCommNewsAcctImport::GetSubListGroups(char *pFileName, char **ppListGroups)
{
    HRESULT hr                      =   E_FAIL;
    HANDLE	hRCHandle				=	NULL;
	HANDLE	hRCFile					=	NULL;
	ULONG	cbRCFile				=	0;
	BYTE	*pBegin					=	NULL, 
			*pCurr					=	NULL, 
			*pEnd					=	NULL;
    int     nBalMem                 =   MEMCHUNK;
    int     nLine                   =   0,
            nCount                  =   0;
    char    cPlaceHolder            =   1;
    char    szLineHolder[MEMCHUNK];
    char    *pListGroups            =   NULL;
    
    Assert(lstrlen(pFileName));
    Assert(ppListGroups);
    *ppListGroups = NULL;

    hRCHandle = CreateFile( pFileName, GENERIC_READ, FILE_SHARE_READ, NULL, 
							OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);

	if(hRCHandle == INVALID_HANDLE_VALUE)
		return hr;

	cbRCFile = GetFileSize(hRCHandle, NULL);

    if(!cbRCFile) // Empty File.
        goto Done;

	hRCFile = CreateFileMapping(hRCHandle, NULL, PAGE_READONLY, 0, 0, NULL);

	if(hRCFile == NULL)
    {
        CloseHandle(hRCHandle);
		return hr;
    }

    pBegin = (BYTE *)MapViewOfFile( hRCFile, FILE_MAP_READ, 0, 0, 0);

	if(pBegin == NULL)
    {
        CloseHandle(hRCHandle);
        CloseHandle(hRCFile);
		return hr;
    }

	pCurr = pBegin;
	pEnd = pCurr + cbRCFile;

    if (!MemAlloc((void **)&pListGroups, MEMCHUNK))
    {
        hr = E_OUTOFMEMORY;
        goto Done;
    }

    DWORD cchSizeListGroups = MEMCHUNK;
    ZeroMemory((void*)pListGroups, (cchSizeListGroups * sizeof(pListGroups[0])));
	
    while (pCurr < pEnd)
    {
        nLine = 0;
        while(!((pCurr[nLine] == ':') || (pCurr[nLine] == '!')) && (pCurr + nLine < pEnd))
            nLine++;

        if(pCurr + nLine > pEnd)
            break;

        if(pCurr[nLine] == '!')
            goto LineEnd;

        nLine++;
        if(nLine < MEMCHUNK)
            StrCpyN(szLineHolder, (char*)pCurr, nLine);
        else
            continue;

        if(nLine + 2 < nBalMem)
        {
            StrCatBuff(pListGroups, szLineHolder, cchSizeListGroups);
            StrCatBuff(pListGroups, "\1", cchSizeListGroups);
            nBalMem -= (nLine + 2);
        }
        else
        {
            cchSizeListGroups += (lstrlen(pListGroups) + 1 + MEMCHUNK);
            if(!MemRealloc((void **)&pListGroups, (cchSizeListGroups * sizeof(pListGroups[0]))))
            {
                hr = E_OUTOFMEMORY;
                goto Done;
            }
            nBalMem += MEMCHUNK;
            StrCatBuff(pListGroups, szLineHolder, cchSizeListGroups);
            StrCatBuff(pListGroups, "\1", cchSizeListGroups);
            nBalMem -= (nLine + 2);
        }

LineEnd:
        while(!((pCurr[nLine] == 0x0D) && (pCurr[nLine + 1] == 0x0A)) && (pCurr + nLine < pEnd))
            nLine++;
        pCurr += (nLine + 2);
    }

    if(lstrlen(pListGroups))
    {
        while(pListGroups[nCount] != '\0')
        {
            if(pListGroups[nCount] == cPlaceHolder)
            {
                pListGroups[nCount] = '\0';
            }
            nCount++;
        }
        *ppListGroups = pListGroups;
        hr = S_OK;
    }

Done:
    if(pBegin)
        UnmapViewOfFile(pBegin);
    if(hRCHandle != INVALID_HANDLE_VALUE)
        CloseHandle(hRCHandle);
    if(hRCFile)
        CloseHandle(hRCFile);

    return hr;
}

const static char c_szSearch[][NEWSUSERCOLS]  = {"user_pref(\"network.hosts.nntp_server\"", 
                                                 "user_pref(\"news.server_port\"", 
                                                 "user_pref(\"mail.identity.username\"", // This is the same for NNTP also.
                                                 "user_pref(\"mail.identity.useremail\""};
const static char c_szPrefs[]                 =  "\\prefs.js";

HRESULT CCommNewsAcctImport::GetUserPrefs(char *szUserPath, char szUserPrefs[][NEWSUSERCOLS], int nInLoop, BOOL *pbPop)
{
    HRESULT hr                      =   E_FAIL;
    char	szTemp[MAX_PATH * 2];
	char	szDirpath[250];
	char	szLine[1000];
	char	szCompare[1000];
	int		nLine					=	0;
    int     nFilled                 =   0;
	int		nPosition				=	0;
    int     nLoop                   =   nInLoop;
	HANDLE	hJSHandle				=	NULL;
	HANDLE	hJSFile					=	NULL;
	ULONG	cbJSFile				=	0;

	BYTE	*pBegin					=	NULL, 
			*pCurr					=	NULL, 
			*pEnd					=	NULL;
			
    Assert(nInLoop <= NEWSUSERROWS);
	StrCpyN(szTemp, szUserPath, ARRAYSIZE(szTemp));
	StrCatBuff(szTemp, c_szPrefs, ARRAYSIZE(szTemp));

	hJSHandle = CreateFile( szTemp, GENERIC_READ, FILE_SHARE_READ, NULL, 
							OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);

	if(hJSHandle == INVALID_HANDLE_VALUE)
		return hr;

	cbJSFile = GetFileSize(hJSHandle, NULL);

	hJSFile = CreateFileMapping(hJSHandle, NULL, PAGE_READONLY, 0, 0, NULL);

	if(hJSFile == NULL)
    {
        CloseHandle(hJSHandle);        
		return hr;
    }

    pBegin = (BYTE *)MapViewOfFile( hJSFile, FILE_MAP_READ, 0, 0, 0);

	if(pBegin == NULL)
    {
        CloseHandle(hJSHandle);
        CloseHandle(hJSFile);
		return hr;
    }

	pCurr = pBegin;
	pEnd = pCurr + cbJSFile;
	
    while (pCurr < pEnd)
	{
		szLine[nLine] = *pCurr; //keep storing here. will be used for comparing later. 
		if((pCurr[0] == 0x0D) && (pCurr[1] == 0x0A))
		{
            while(nLoop)
            {
                StrCpyN(szCompare, szLine, lstrlen(c_szSearch[nLoop - 1]) + 1);
				if(lstrcmp(szCompare, c_szSearch[nLoop - 1]) == 0)   
				{
                    //Found a UserPref one of the things we are looking for"!
					//Extract the stuff we want.
					nPosition	=	lstrlen(c_szSearch[nLoop - 1]);
					
					while (((szLine[nPosition] == '"')||(szLine[nPosition] == ' ')||(szLine[nPosition] == ',')) &&(nPosition < nLine))
						nPosition++;
					StrCpyN(szDirpath, &szLine[nPosition], nLine - nPosition);

					//Now trim the trailing edge!!!

					nPosition	=	lstrlen(szDirpath) - 1;
					while((szDirpath[nPosition] == '"') || (szDirpath[nPosition] == ')')||(szDirpath[nPosition] == ';')) 
					{
						szDirpath[nPosition] = '\0';
						nPosition	=	lstrlen(szDirpath) - 1;
					}
 
                    StrCpyN(szUserPrefs[nLoop - 1], szDirpath, NEWSUSERCOLS);
                    nFilled++;
                    if(nFilled == nInLoop)
                        break;
				}
                nLoop--;
			}
            nLoop = nInLoop;
			nLine = -1; //the nLine++ that follows will make nLine zero.
			pCurr++;
		}
        if(nFilled == nInLoop)
            break;
		pCurr++;
		nLine++;
	}

    if(pBegin)
        UnmapViewOfFile(pBegin);

    if(hJSHandle != INVALID_HANDLE_VALUE)
        CloseHandle(hJSHandle);

    if(hJSFile)
        CloseHandle(hJSFile);

	if(nFilled == 0)
        return E_FAIL;
	else
    {
        if(nInLoop == 1)    //If this function was called only to check the server enties...
        {
            if(lstrlen(szUserPrefs[0]))
                return S_OK;
            else
                return E_FAIL;
        }
        return S_OK;
    }
}

HRESULT CCommNewsAcctImport::GetSettings(DWORD_PTR dwCookie, IImnAccount *pAcct)
{
    HRESULT hr;

    if (pAcct == NULL)
        return(E_INVALIDARG);    

    hr = IGetSettings(dwCookie, pAcct, NULL);

    return(hr);
}

HRESULT CCommNewsAcctImport::IGetSettings(DWORD_PTR dwCookie, IImnAccount *pAcct, IMPCONNINFO *pInfo)
{
    NEWSSERVERS *pPrevServ = m_rgServ;
    COMMNEWSACCTINFO *pinfo;
    char szUserPrefs[NEWSUSERROWS][NEWSUSERCOLS];
    char sz[512];
    DWORD cb, type;
    HRESULT hr;
    BOOL bPop   =   TRUE;
    char szNntpServ[NEWSUSERCOLS];
    char szNntpPort[NEWSUSERCOLS];
    szNntpPort[0] = '\0';
    int nReach = 0;
    DWORD dwNewsPort = 119;
    
    Assert(pPrevServ);
    Assert(m_dwSelServ < m_nNumServ);
            
    for(DWORD nCount = 0; nCount < m_dwSelServ; nCount++)
        pPrevServ = pPrevServ->pNext;

    StrCpyN(szNntpServ, pPrevServ->szServerName, ARRAYSIZE(szNntpServ));
    while(szNntpServ[nReach] != '\0')
    {
        if(szNntpServ[nReach] == ':')
        {
            szNntpServ[nReach] = '\0';
            StrCpyN(szNntpPort, &szNntpServ[nReach+1], ARRAYSIZE(szNntpPort));
            break;
        }
        nReach++;
    }

    Assert(lstrlen(szNntpServ) > 0);

    ZeroMemory((void*)&szUserPrefs[0], NEWSUSERCOLS*NEWSUSERROWS*sizeof(char));

    Assert(((int) dwCookie) >= 0 && dwCookie < (DWORD_PTR)m_cInfo);
    pinfo = &m_rgInfo[dwCookie];
    
    Assert(pinfo->dwCookie == dwCookie);

    hr = GetUserPrefs(pinfo->szUserPath, szUserPrefs, NEWSUSERROWS, &bPop);
    Assert(!FAILED(hr));
   
    hr = pAcct->SetPropSz(AP_ACCOUNT_NAME, szNntpServ);
    if (FAILED(hr))
        return(hr);

    hr = pAcct->SetPropSz(AP_NNTP_SERVER, szNntpServ);
    Assert(!FAILED(hr));

    int Len = lstrlen(szNntpPort);
    if(Len)
    {
        // Convert the string to a dw.
        DWORD dwMult = 1;
        dwNewsPort = 0;
        while(Len)
        {
            Len--;
            dwNewsPort += ((int)szNntpPort[Len] - 48)*dwMult;
            dwMult *= 10;
        }
    }

    hr = pAcct->SetPropDw(AP_NNTP_PORT, dwNewsPort);
    Assert(!FAILED(hr));
 
    if(lstrlen(szUserPrefs[2]))
    {
        hr = pAcct->SetPropSz(AP_NNTP_DISPLAY_NAME, szUserPrefs[2]);
        Assert(!FAILED(hr));
    }

    if(lstrlen(szUserPrefs[3]))
    {
        hr = pAcct->SetPropSz(AP_NNTP_EMAIL_ADDRESS, szUserPrefs[3]);
        Assert(!FAILED(hr));
    }

    if (pInfo != NULL)
    {
        // TODO: can we do any better than this???
        pInfo->dwConnect = CONN_USE_DEFAULT;
    }
    
    return(S_OK);
}

STDMETHODIMP CCommNewsAcctImport::GetSettings2(DWORD_PTR dwCookie, IImnAccount *pAcct, IMPCONNINFO *pInfo)
{
    if (pAcct == NULL ||
        pInfo == NULL)
        return(E_INVALIDARG);
    
    return(IGetSettings(dwCookie, pAcct, pInfo));
}

CEnumCOMMNEWSACCT::CEnumCOMMNEWSACCT()
    {
    m_cRef = 1;
    // m_iInfo
    m_cInfo = 0;
    m_rgInfo = NULL;
    }

CEnumCOMMNEWSACCT::~CEnumCOMMNEWSACCT()
    {
    if (m_rgInfo != NULL)
        MemFree(m_rgInfo);
    }

STDMETHODIMP CEnumCOMMNEWSACCT::QueryInterface(REFIID riid, LPVOID *ppv)
    {

    if (ppv == NULL)
        return(E_INVALIDARG);

    *ppv = NULL;

    if (IID_IUnknown == riid)
		*ppv = (IUnknown *)this;
	else if (IID_IEnumIMPACCOUNTS == riid)
		*ppv = (IEnumIMPACCOUNTS *)this;

    if (*ppv != NULL)
        ((LPUNKNOWN)*ppv)->AddRef();
    else
        return(E_NOINTERFACE);

    return(S_OK);
    }

STDMETHODIMP_(ULONG) CEnumCOMMNEWSACCT::AddRef()
    {
    return(++m_cRef);
    }

STDMETHODIMP_(ULONG) CEnumCOMMNEWSACCT::Release()
    {
    if (--m_cRef == 0)
        {
        delete this;
        return(0);
        }

    return(m_cRef);
    }

HRESULT STDMETHODCALLTYPE CEnumCOMMNEWSACCT::Next(IMPACCOUNTINFO *pinfo)
    {
    if (pinfo == NULL)
        return(E_INVALIDARG);

    m_iInfo++;
    if ((UINT)m_iInfo >= m_cInfo)
        return(S_FALSE);

    Assert(m_rgInfo != NULL);

    pinfo->dwCookie = m_rgInfo[m_iInfo].dwCookie;
    pinfo->dwReserved = 0;
    StrCpyN(pinfo->szDisplay, m_rgInfo[m_iInfo].szDisplay, ARRAYSIZE(pinfo->szDisplay));

    return(S_OK);
    }

HRESULT STDMETHODCALLTYPE CEnumCOMMNEWSACCT::Reset()
    {
    m_iInfo = -1;

    return(S_OK);
    }

HRESULT CEnumCOMMNEWSACCT::Init(COMMNEWSACCTINFO *pinfo, int cinfo)
    {
    DWORD cb;

    Assert(pinfo != NULL);
    Assert(cinfo > 0);

    cb = cinfo * sizeof(COMMNEWSACCTINFO);
    
    if (!MemAlloc((void **)&m_rgInfo, cb))
        return(E_OUTOFMEMORY);

    m_iInfo = -1;
    m_cInfo = cinfo;
    CopyMemory(m_rgInfo, pinfo, cb);

    return(S_OK);
    }