Re: Terminating Accept

From:

Hector Santos <sant9442@nospam.gmail.com>

Newsgroups:

microsoft.public.vc.mfc

Date:

Mon, 22 Mar 2010 11:58:43 -0400

Message-ID:

<Oq1jLidyKHA.3408@TK2MSFTNGP06.phx.gbl>

There are two design methods here:

    1) Synchronous Listening socket
    2) Asynchronous Listening socket

For sync, you would put a sync socket in a thread and to break out of
the accept(), you will invalidate the listening socket handle.

For async, you can also break out (error) of the accept() by
invalidating the listening socket handle, but since its async, you
will missing time to react to connections.

It looks like you started a thread for the listener. You need to be
able to invalidate the socket handle so that the blocking accept
returns from the function. Overall, for SYNC, its like this:

SOCKET ListenSocket = INVALID_SOCKET; // global

void listening_thread()
{
     ....

     while (1) {
         sockaddr_in src;
         int x = sizeof(src);
         SOCKET t = accept(ListenSocket, (sockaddr *)&src, &x);
         if (t != INVALID_SOCKET) {

             spawn new client thread passing t and src as
             socket and peer info. The client itself should
             release the t socket.
         } else {
             // can check for error if you want
             break;
         }
     }

     ...

} // listening thread

and now some main thread action will invalidate the handle by closing it.

But you are using CAsyncSocket within a MFC GUI application. This
already provides you with the OnAccept(). You should prepare the MFC
socket server to use this. Your code will be a lot cleaner.

--
HLS

dushkin wrote:

Hi All.

Recently I posted a question (http://groups.google.com/group/
microsoft.public.vc.mfc/browse_thread/thread/6ec9bd3dc80c408e#) about
a problem regarding closing an app using a system tray icon menu.

What I didn't know till now is that the problem was a
CAsyncSocket::Accept() function that was waiting for a connection and
probably blocked some messaging or something. Therfore the application
never exited. When I removed the accept function part - the closing of
the app via the system tray menu succeeded.

So I tried to move the listen/accept while loop into a separate
thread. I thought that this way the accept won't interfere in closing
the app. But then, when I tried to stop the "accept" with some closing
functions as you will see in the code, in order to allow the "Exit"
app in the menu to work, the CAsyncSocket::Close() crashed and the
accept didn't stop working anyway.

I read somewhere that you wouldn't like to put this loop in a thread.

My question is how to deal with this problem.

Actually, I think I need to somehow stop the "Accept" operation and
thus allow the system tray messages to work.

How do I do it?

Following is the class code. I removed some of the AboutBox code and
some other irrelevant code. I use a class for the system tray
functionality.

Thanks.

--------------------------------------------------------------------------

// PAADlg.cpp : implementation file
//

#include "stdafx.h"
#include "PAA.h"
#include "PAADlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

bool g_stop = false;
CEvent gEvent;

UINT RunListener(LPVOID lpParam);

// CPAADlg dialog

CPAADlg::CPAADlg(CWnd* pParent /*=NULL*/)
    : CDialog(CPAADlg::IDD, pParent)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    m_DefaultMenuItemByPos = TRUE;
    m_pParentWnd = pParent;
}

CPAADlg::~CPAADlg(){

    g_stop = true;

        //Trying to close Accept operation when exiting app
    m_ListeningSocket.CancelBlockingCall();
    m_ListeningSocket.ShutDown();
    m_ListeningSocket.Close();
    m_ConnectedSocket.Close();

    WaitForSingleObject(gEvent.m_hObject, INFINITE);

    m_autoLog.Close();

}

void CPAADlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CPAADlg, CDialog)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    //}}AFX_MSG_MAP
    ON_MESSAGE(WM_ICON_NOTIFY, OnTrayNotification)
END_MESSAGE_MAP()

// CPAADlg message handlers

BOOL CPAADlg::OnInitDialog()
{
    CDialog::OnInitDialog();

    // Add "About..." menu item to system menu.

    // IDM_ABOUTBOX must be in the system command range.
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL)
    {
        BOOL bNameValid;
        CString strAboutMenu;
        bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
        ASSERT(bNameValid);
        if (!strAboutMenu.IsEmpty())
        {
            pSysMenu->AppendMenu(MF_SEPARATOR);
            pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
        }
    }

    // Set the icon for this dialog. The framework does this
automatically
    // when the application's main window is not a dialog
    SetIcon(m_hIcon, TRUE); // Set big icon
    SetIcon(m_hIcon, FALSE); // Set small icon

    //HICON hIcon = ::LoadIcon(NULL, IDI_ASTERISK);
    HICON hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    if (!m_TrayIcon.Create(NULL, WM_ICON_NOTIFY, "Hello", hIcon,
IDR_POPUP_MENU))
        return -1;

    if(! CreateLogFile())
        return FALSE;

    gEvent.ResetEvent();

    CWinThread* pThread = AfxBeginThread(RunListener ,this);
    if(!pThread)
        AfxMessageBox("Thread Error!");

    return TRUE; // return TRUE unless you set the focus to a control
}

void CPAADlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialog::OnSysCommand(nID, lParam);
    }
}

// If you add a minimize button to your dialog, you will need the code
below
// to draw the icon. For MFC applications using the document/view
model,
// this is automatically done for you by the framework.
BOOL CPAADlg::CreateLogFile()
{
    CFileException e;
    if(!m_autoLog.Open("c:\\AutoPaAgn.log", CFile::modeCreate|
CFile::modeNoTruncate|CFile::modeWrite, &e)){
        CString s;
        s.Format("%d", e.m_cause);
        AfxMessageBox(s);
        return FALSE;
    }
    return TRUE;
}

void CPAADlg::WriteToFile(CString a_sLine)
{
    CTime tm = CTime::GetCurrentTime();
    m_autoLog.WriteString(tm.Format("%H.%M.%S : ") + a_sLine);
}

LRESULT CPAADlg::OnTrayNotification(WPARAM wParam, LPARAM lParam)
{
    //Return quickly if its not for this tray icon
    if (wParam != m_tnd.uID)
        return 0L;

    CMenu menu, *pSubMenu;

    // Clicking with right button brings up a context menu
    if (LOWORD(lParam) == WM_RBUTTONUP)
    {
        if (!menu.LoadMenu(m_tnd.uID))
            return 0;

        pSubMenu = menu.GetSubMenu(0);
        if (!pSubMenu)
            return 0;

        // Display and track the popup menu
        CPoint pos;
        GetCursorPos(&pos);

        SetForegroundWindow();

        pSubMenu->TrackPopupMenu(TPM_LEFTALIGN, pos.x, pos.y, this, NULL);

        PostMessage(WM_NULL, 0, 0);

        menu.DestroyMenu();
    }
    else if (LOWORD(lParam) == WM_LBUTTONDBLCLK)
    {
        // double click received, the default action is to execute default
menu item
        SetForegroundWindow();

        UINT uItem;
        if (m_DefaultMenuItemByPos)
        {
            if (!menu.LoadMenu(m_tnd.uID))
                return 0;

            pSubMenu = menu.GetSubMenu(0);
            if (!pSubMenu)
                return 0;

            uItem = pSubMenu->GetMenuItemID(m_DefaultMenuItemID);

            menu.DestroyMenu();
        }
        else
            uItem = m_DefaultMenuItemID;

        PostMessage(WM_COMMAND, uItem, 0);
    }

    return 1;
}

BOOL CPAADlg::SetMenuDefaultItem(UINT uItem, BOOL bByPos)
{
    if ((m_DefaultMenuItemID == uItem) && (m_DefaultMenuItemByPos ==
bByPos))
        return TRUE;

    m_DefaultMenuItemID = uItem;
    m_DefaultMenuItemByPos = bByPos;

    CMenu menu, *pSubMenu;

    if (!menu.LoadMenu(m_tnd.uID))
        return FALSE;

    pSubMenu = menu.GetSubMenu(0);
    if (!pSubMenu)
        return FALSE;

    ::SetMenuDefaultItem(pSubMenu->m_hMenu, m_DefaultMenuItemID,
m_DefaultMenuItemByPos);

    return TRUE;
}

void CPAADlg::GetMenuDefaultItem(UINT& uItem, BOOL& bByPos)
{
    uItem = m_DefaultMenuItemID;
    bByPos = m_DefaultMenuItemByPos;
}

UINT RunListener(LPVOID lpParam)
{
    CPAADlg * pDlg = (CPAADlg *)lpParam;

    if (pDlg->m_ListeningSocket.Create(5555))
    {
        while(true)
        {
            pDlg->WriteToFile("Agent - Socket Created\n");
            if (pDlg->m_ListeningSocket.Listen())
            {
                pDlg->WriteToFile("Agent - Wait for next message\n");

                if (pDlg->m_ListeningSocket.Accept(pDlg->m_ConnectedSocket))
                {
                    if(g_stop)
                        break;

                    pDlg->WriteToFile("Agent - Message Accepted\n");
                    char *pBuf = new char[1025];
                    int iBufSize = 1024;
                    int iRcvd;

                    iRcvd = pDlg->m_ConnectedSocket.Receive(pBuf, iBufSize, 0);

                    pDlg->WriteToFile("Agent - Message Received\n");

                    if (iRcvd == SOCKET_ERROR)
                    {
                        CString s;
                        s.Format("Agent - Receive Error: %d\n", GetLastError());
                        pDlg->WriteToFile(s);
                    }
                    else
                    {
                        pDlg->m_ConnectedSocket.GetPeerName(pDlg->PeerAddress(), pDlg-

PeerPort());

pBuf[iRcvd] = NULL;

                        pDlg->WriteToFile("Agent - Handle Message\n");

                        RegDeleteKey(HKEY_LOCAL_MACHINE, "SOFTWARE\\AutoIt3Att\\Scripts\
\Flags");

                        if(pDlg->RunScript(pBuf))
                            pDlg->SendCompletionAck();
                    }
                    pDlg->m_ConnectedSocket.Detach();
                }
                else{
                    CString s;
                    s.Format("Agent - Accept Error: %d\n", GetLastError());
                    pDlg->WriteToFile(s);
                }
            }
            else{
                CString s;
                s.Format("Agent - Listen Error: %d\n", GetLastError());
                pDlg->WriteToFile(s);
            }
        }
    }

    gEvent.SetEvent();
    //pDlg->m_ListeningSocket.Close();
    return 0;
}

bool CPAADlg::RunScript(char a_sScriptName[])
{
    CString s("Agent - RunScript ");
    WriteToFile( s + a_sScriptName + "\n");

    CString sScriptFullPath = sLibrary + a_sScriptName + ".au3";
    CString cmdLine;

    cmdLine.Format("\"c:\\Program Files\\AutoIt3\\AutoIt3.exe\" \"%s\"",
sScriptFullPath);

    STARTUPINFO si;
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof STARTUPINFO;

    PROCESS_INFORMATION pi;
    BOOL res = CreateProcess(NULL,
        cmdLine.GetBuffer(),
        NULL,
        NULL,
        NULL,
        NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW,
        NULL,
        NULL,
        &si,
        &pi);

    if (TRUE == res)
    {
        WriteToFile("Agent - RunScript - Process created\n");
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        return true;
    }

    return false;
}

void CPAADlg::SendCompletionAck(void)
{
    while (1)
    {
        char Buf[10];
        HKEY hKey;
        DWORD type = REG_SZ;
        long lRetCode;
        DWORD size = 10;

        lRetCode = RegOpenKeyEx ( HKEY_LOCAL_MACHINE, "SOFTWARE\\AutoIt3Att\
\Scripts\\Flags", 0,KEY_READ,&hKey);

        if (lRetCode == ERROR_SUCCESS){

            WriteToFile("Agent - SendCompletionAck - Opened Complete Flag
registry Key\n");

            lRetCode=::RegQueryValueEx(hKey,"Completed",NULL,NULL,(unsigned
char *)Buf,&size);

            if(lRetCode == ERROR_SUCCESS){

                Buf[1]=0;//the flag is 1 byte long: "1" or "0"

                if (strcmp(Buf, "1") == 0)
                {
                    WriteToFile("Agent - SendCompletionAck - Complete Flag registry
Key is 1\n");

                    CSocket sock;
                    if (sock.Create())//on any port
                    {
                        WriteToFile("Agent - SendCompletionAck Socket Created\n");
                        CString s;
                        s.Format("Agent - Peer IP is %s\n", m_sPeerAddress);
                        WriteToFile(s);
                        if (sock.Connect(m_sPeerAddress, 6666))
                        {
                            WriteToFile("Agent - SendCompletionAck Socket Connected\n");
                            int iAmtSent;
                            char buf[] ="1";

                            iAmtSent = sock.Send(buf, 1);

                            WriteToFile("Agent - Sent Completion Ack\n");
                            return;
                        }
                        else
                        {
                            CString s;
                            s.Format("Agent - SendCompletionAck Socket Connect Error: %d
\n", GetLastError());
                            WriteToFile(s);
                        }
                    }
                    else
                    {
                        CString s;
                        s.Format("Agent - SendCompletionAck Socket Create Error: %d\n",
GetLastError());
                        WriteToFile(s);
                    }
                }else{
                    WriteToFile("Agent - SendCompletionAck - Complete Flag registry
Key is 0\n");
                }
            }
            else
            {
                WriteToFile("Agent - SendCompletionAck - Failed to read Complete
Flag registry Key\n");
            }

            RegCloseKey(hKey);

        }
        else
        {
            WriteToFile("Agent - SendCompletionAck - Failed to open Complete
Flag registry Key\n");
        }

        Sleep(1000);

    }//end while
}

--
HLS