Технология Клиент-Сервер 1998'3
	Home Поиск Издания Контакты k-press.ru

Продолжается подписка на наши издания! Вы не забыли подписаться?

Рисунок 11. HTTP ObjectServer

HTTPObjectServer.idl

// HttpObjectServer.idl : IDL source for HttpObjectServer.dll
// This file will be processed by the MIDL tool to
// produce the type library (HttpObjectServer.tlb) and marshalling code.

import “oaidl.idl”;
import “ocidl.idl”;

[
  uuid(10BE7FE8-9CC7-11D1-9912-004033D06B6E),
  helpstring(“IHttpRequest Interface”),
  pointer_default(unique)
]
interface IHttpRequest : IUnknown //IDispatch
{
  [helpstring{“method ProcessRequest”)] HRESULT ProcessRequest(
    IUnknown* pQuoteProvider, long lMainHwnd);
  [helpstring(“method GetProviderInterface”)] HRESULT
    GetProviderlnterface(IUnknown** ppUnk);
};

[
  uuid(108E7FDB-9CC7-11D1-9912-004033D06B6E),version(1.0),
  helpstring(“HttpObjectServer 1.0 Type Library”)
]
library HTTPOBJECTSERVERLib
{
  importlib(“stdole32.tlb”);
  importlib(“stdole2.tlb”);

  [
    uuid(10BE7FE9-9CC7-11D1-9912-004033D06B6E),
    helpstring(“HttpRequest Class”)
  ]
  coclass HttpRequest
  {
    [default] interface IHttpRequest;
  };
};

HTTPRequest.h

// HttpRequest.h : Declaratton of the CHttpRequest

#ifndef __HTTPREQUEST_H_
#define __HTTPREQUEST_H_

#include “resource.h”       // main symbols
#include “..\QuoteProviders\QuoteProviders.h”

/////////////////////////////////////////////////////////////////////////////
// CHttpRequest
class ATL_NO_VTABLE CHttpRequest :
  public CComObjectRootEx<CComSingleThreadModel>,
  public CComCoClass<CHttpRequest. &CLSID_HttpRequest>,
  public IHttpRequest
{
public:
  CHttpRequest()
  {
    m_pQuoteProvider = NULL;
  }

  ~CHttpRequest()
  {
    //release the IQuoteProvider interface
    if (m_pOuoteProvider)
      m_pQuoteProvider->Release();
  }
  
  //pointer to current quote provider interface
  IQuoteProvider* m_pQuoteProvider;
    
//main application HWNDHWND m_hwndMain;
DECLARE_REGISTRY_RESOURCEID(IDR_HTTPREOUEST)

BEGIN_COM_MAP(CHttpRequest)
  COM_INTERFACE_ENTRY(IHttpRequest)
END_COM_MAP()

// IHttpRequest
public:
  STDMETHOD(GetProviderInterface)(IUnknown** ppUnk);
  STDMETHOD(ProcessRequest)(IUnknorn* pQuoteProvider, long lMainHwnd);
};

#endif //__HTTPREQUEST_H_

MyInternetSession.h

// MyInternetSession.h: Declaration of CMyInternetSession
//
class CMyInternetSession : 
  public CInternetSession
{
public:
  CMyInternetSession(LPCTSTR pstrAgent = NULL. DWORD drContext = l,
      DWORD dwAccessType = INTERNET_OPEN_TYPE_PRECONFIG,
      LPCTSTR pstrProxyName = NULL,
      LPCTSTR pstrProxyBypass = NULL,
      DWORD dwFlags = 0 )
    : CInternetSession(pstrAgent, dwContext, dwAccessType, pstrProxyName,
        pstrProxyBypass, dwFlags) { m_pRequest=NULL; };
  
  //override OnStatusCallback
  virtual void OnStatusCallback(DWORD dwContext, DWORD dwInternetStatus,
    LPVOID lpvStatusInformation, DWORD dwStatusInformationLength );
  
  //pointer to the CHttpRequest object controlling this Internet session
  CHttpRequest* m_pRequest;
};

HTTPRequest.cpp

// HttpRequest.cpp : Implementation of CHttpRequest

#include “stdafx.h”
#include “HttpObjectServer.h
#include “HttpRequest.h”
#include “MyInternetSession.h
#include “LoginDlg.h”
#include “profile.h”
#include “..\QuoteProviders\QuoteProviders.h”
#include “..\Stack Watcher\globals.h”

#define HTTPFILE_BUFFLEN    4096
#define BUFFLEN         255

extern CRITICAL_SECTION g_CS;

UINT HttpWorkerThread(LPVOID lpVoid);

/////////////////////////////////////////////////////////////////////////////
// CMyInternetSession

void CMyInternetSession::OnStatusCallback(DWORD dwContext, DWORD dwInternetStatus,
  LPVOID lpvStatusInformation, DWORD dwStatusInformationLength )
{
  if (m_pRequest)
  {
    if ( m_pRequest->a hwndMain)
      ::PostMessage(m_pRequest->m_hwndMain, WM_HTTP_THREAD_MESSAGE,
        UPDATE_STATUS, dwInternetStatus);
  }
}

////////////////////////////////////////////////////////////////////////////// 
// CHttpRequest

STDMETHODIMP CHttpRequest::ProcessRequest(IUnknorn* pQuoteProvider,
  long lMainHwnd)
{
  AFX_MANAGE_STATE(AfxGetStaticModuleState())
  m_pQuoteProvider = static_cast<IQuoteProvider*>(pQuoteProvider);
  m_pQuoteProvider->AddRef();
  m_hwndMain = reinterpret_cast<HWND>(lMainHwnd);
  AfxBeginThread(HttpWorkerThread, this);
  return S_OK;
}

STDMETHODIMP CHttpRequest::GetProviderlnterface(IUnknown * * ppUnk)  
{
  AFX_MANAGE_STATE(AfxGetStaticModuleState())  *ppUnk = m_pQuoteProvider;
  return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
// HttpWorkerThread

UINT HttpWorkerThread(LPVOID lpVoid)
{
  CHttpRequest* pRequest = reinterpret_cast<CHttpRequest*>(lpVoid);
  IQuoteProvider* pProvider = pRequest->m_pQuoteProvider;
  CHttpConnectton* pHttptonnection = NULL;
  CHttpFile* pHttpFile = NULL;
  LPVOID lpvoid = NULL;
  char lpszHost[BUFFLEN], lpszUserName[BUFFLEN], lpszPassword[BUFFLEN],
    lpszMethod[BUFFLEN];
  char lpszURL[BUFFLEN], lpszAcceptTypes[BUFFLEN], lpstHttpVersion[BUFFLEN],
    lpszHeaders[BUFFLEN]; char lpszData[BUFLEN];
  DWORD dwFlags;
  LPCTSTR pstrAcceptTypes[2];
  INTERNET_PORT nPort;
  BOOL bResult;
  
  //declare CMylnternetSesston object
  CMylnternetSession InternetSession(NULL, 1, INTERNET_OPEN_TYPE_PRECOHFIG);
  try
  {
    //enable the status callback
    InternetSession.EnableStatusCallback(TRUE);
    InternetSession.m_pRequest = pRequest;
    //get connection information
    pProvider->GetHost(lpszHost, BUFFLEN);
    pProvider->GetPort(&nPort);
    pProvider->LoginIsRequired(&bResult);
    if (bResult)
    {
      CString strUserName = GetMyProfileString{“Settings”, “username”, “”);
      CString strPassword = GetMyProfileString(“Settings”, “password”, “”);
      if (strUserName.IsEmpty() || strPassword.IsEmpty{))
      {
        // get user name & password information
        CLoginDlg dlg;
        if (IDCANCEL == dlg.DoModal())
          return 0;
        WriteMyProfileString(“Settings”, “username”, dlg.m_strUserName);
        WriteMyProfileString{“Settings”, “password”, dlg.m_strPassword);
        strcpy(lpszUserName. dlg.m_strUserName);
        strcpy(lpszPassword, dlg.m_strPassword);
      }
      else
      {
        strcpy(lpszUserHaae. strUserName);
        strcpy(lpszPassword, strPassword);
      }
    }
    //establish the HTTP connection
    pHttpConnection = InternetSession.GetHttpConnection( lpszHost, nPort,
      lpszUserName, lpszPassword);
    //get request specific information
    pProvider->GetMethod(lpszMethod, BUFFLEN);
    pProvider->GetURL(lpszURL, BUFFLEN);
    pProvider->GetAcceptTypes(lpszAcceptTypes, BUFFLEN);
    pstrAcceptTypes[O] = lpszAcceptTypes;
    pstrAcceptTypes[l] = NULL;
    pProvider->GetHttpVersion(lpszHttpVersion, BUFFLEN);
    pProvider->GetFlags(&dwFlags);
    
    //open the HTTP request
      pHttpFile = pHttpConnection->OpenRequest(lpszMethod, lpszURL, “”, 1,
        pstrAcceptTypes, lpszHttpVersion, dwFlags);
    //get the request data
    pProvider->GetHeaders(lpszHeaders, BUFFLEN);
    pProvider->GetData(lpszData, BUFFLEN);
    if (pHttpFile->SendRequest(lpszHeaders, strlen(lpszHeaders),
      static cast<void*>(lpszData), strlen(lpszData)))
    {
      DWORD dwRet;
      //query the HTTP status code
      pHttpFile->QueryInfoStatusCode(dwRet);
      //authentication techniques
      while (dwRet == HTTP_STATUS_DENIED){
        CLogInDlg dlg;
        dlg.m_strUserName = GetMyProfileString(“Settings”,
          “username”, “”);
        dlg.m_strPassword = GetMyProfileString(“Settings”,
          “password”, “”);
        if (IDCANCEL == dlg.DoModal())
        {
          if (pHttpConnection)
          {
            pHttpConnection->Close();delete pHttpConnection;
          }
          if (pHttpFile)
          {
            pHttpFile->Close();
            delete pHttpFile;
          }
          return 0;
        }
        WriteMyProfileString(“Settings”, “username”. dlg.m_ strUserName);
        WriteMyProfileString(“Settings”, “password”. dlg.m_strPassword);
        strcpy(lpszUserName, dlg.m_strUserName);
        strcpy(lpszPassword, dlg.m_strPassword);
        InternetSetOption((INTERNET)(‘pHttpFile),
          INTERNET_OPTION_USERNANE, lpszUserName, strlen(lpszUserName));
        InternetSetOption((HINTERNET)(*pHttpFile),
          INTERNET_OPTION_PASSWORD, lpszPassword, strlen(lpszPassword));
        pHttpFile->SendRequest(lpszHeaders, strlen(lpszHeaders),
          static cast<votd*>(lpszData), strlen(lpszData));
        pHttpFile->QueryInfoStatusCode(dwRet);
      }
      if (dwRet == HTTP_STATUS_OK)
      {
        CString strContentlen;
        LPSTR lpszResult=NULL;
        UINT nRead=O, nTotalRead=0;

        lpvoid = malloc(HTTPFILE_BUFFLEN);
        //memory error
        if (!lpvoid)
          return 0;
        //read the HTTP response
        nRead = pHttpFile->Read(lpvoid, HTTPFILE_BUFFLEN);
        nTotalRead += nRead;
        while <nRead    HTTPFILE BUFFLEII)
        {
          lpvoid = realloc(lpvoid, nTotalRead+HTTPFILE BUFFLEN);
          nRead = pHttpFile->Read((byte*)lpvoid+nTotalRead,
            HTTPFILE_BUFFLEN);
          nTotalRead += nRead;
        }
        lpszResult = (LPSTR)lpvoid;
        *(lpszResult + nTotalRead) = NULL;
        //parse the HTTP response
        EnterCriticalSection(&g_CS);
        HRESULT hr = pProvider->ParseResult(lpszResult);
        if (FAILED(hr))
          ::MessageBox(pRequest->m_hwndHain,
            “Error parsing quote format”,
            “ParseResult Error , MB_ICONEXCLAMATION | MB_OK);
        LeaveCriticalSection(&g_CS);

        //notify the main application window
        if (pRequest->m_hwndMain)
          ::PostMessage(pRequest->m_hwndMain, WM_HTTP_THREAD_MESSAGE,
            UPDATE ALL VIEWS, 0);
      }
    }
  }
  catch(CInternetException *e)
  {
    e->ReportError();
    e->Delete();
  }
  // cleanup
  if (lpvoid)
    free(lpvofd);

  if(pHttpFile)
  {
    pHttpFile->Close();
    delete pHttpFile;
  }
  if (pHttpConnection)
  {
    pHttpConnection->Close();
    delete pHttpConnection;
  }
  return 0;
}

Copyright © 1994-2016 ООО "К-Пресс"