You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
678 lines
17 KiB
678 lines
17 KiB
//--------------------------------------------------------------------------
|
|
//
|
|
// Module Name: LaunStub.Cpp
|
|
//
|
|
// Brief Description:
|
|
// This module contains the code that parses HTTP-based
|
|
// response from the ULS server.
|
|
//
|
|
// Author: Chu, Lon-Chan (lonchanc)
|
|
//
|
|
// Copyright (c) 1996 Microsoft Corporation
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "precomp.h"
|
|
#include "launstub.h"
|
|
|
|
|
|
PTSTR LocalStrDup ( PTSTR pszToDup )
|
|
{
|
|
UINT uLen;
|
|
PTSTR psz = NULL;
|
|
|
|
if (pszToDup)
|
|
{
|
|
uLen = lstrlen (pszToDup);
|
|
psz = (PTSTR) new TCHAR[uLen + 1];
|
|
if (psz)
|
|
{
|
|
lstrcpy (psz, pszToDup);
|
|
}
|
|
}
|
|
|
|
return psz;
|
|
}
|
|
|
|
ULONG DecStrToInt ( PTSTR psz )
|
|
{
|
|
ULONG ul = 0;
|
|
WORD w;
|
|
|
|
if (psz)
|
|
{
|
|
while ((w = (WORD) *psz++) != NULL)
|
|
{
|
|
if (TEXT ('0') <= w && w <= TEXT ('9'))
|
|
{
|
|
w -= TEXT ('0');
|
|
ul = ul * 10 + w;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ul;
|
|
}
|
|
|
|
|
|
ULONG HexStrToInt ( PTSTR psz )
|
|
{
|
|
ULONG ul = 0;
|
|
WORD w;
|
|
|
|
if (psz)
|
|
{
|
|
while ((w = (WORD) *psz++) != NULL)
|
|
{
|
|
if (TEXT ('0') <= w && w <= TEXT ('9'))
|
|
{
|
|
w -= TEXT ('0');
|
|
}
|
|
else
|
|
if (TEXT ('a') <= w && w <= TEXT ('f'))
|
|
{
|
|
w -= (TEXT ('a') - 10);
|
|
}
|
|
else
|
|
if (TEXT ('A') <= w && w <= TEXT ('F'))
|
|
{
|
|
w -= (TEXT ('A') - 10);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
ul = (ul << 4) + w;
|
|
}
|
|
}
|
|
|
|
return ul;
|
|
}
|
|
|
|
BOOL IsWhiteSpace ( TCHAR c )
|
|
{
|
|
return (c == TEXT (' ') || c == TEXT ('\t') || c == TEXT ('\r') || c == TEXT ('\n'));
|
|
}
|
|
|
|
enum
|
|
{
|
|
// beta 3 strings
|
|
ATTR_HR,
|
|
ATTR_PORT,
|
|
ATTR_HA,
|
|
ATTR_HC,
|
|
ATTR_CID,
|
|
ATTR_UID,
|
|
ATTR_URL,
|
|
ATTR_IP,
|
|
ATTR_MT,
|
|
|
|
B3ATTR_COUNT
|
|
};
|
|
|
|
|
|
static PTSTR g_B3Attr[B3ATTR_COUNT] =
|
|
{
|
|
// beta 3 strings
|
|
TEXT ("HR"),
|
|
TEXT ("PORT"),
|
|
TEXT ("HA"),
|
|
TEXT ("HC"),
|
|
TEXT ("CID"),
|
|
TEXT ("UID"),
|
|
TEXT ("URL"),
|
|
TEXT ("IP"),
|
|
TEXT ("MT"),
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
// beta 4 strings
|
|
ATTR_HRESULT,
|
|
ATTR_HCLIENT,
|
|
ATTR_HAPPLICATION,
|
|
ATTR_NAPPS,
|
|
ATTR_IPADDRESS,
|
|
ATTR_PORTNUM,
|
|
ATTR_APPID,
|
|
ATTR_PROTID,
|
|
ATTR_USERID,
|
|
ATTR_MIMETYPE,
|
|
ATTR_APPMIME,
|
|
ATTR_PROTMIME,
|
|
ATTR_QUERYURL,
|
|
|
|
B4ATTR_COUNT
|
|
};
|
|
|
|
|
|
static PTSTR g_B4Attr[B4ATTR_COUNT] =
|
|
{
|
|
// beta 4 strings
|
|
TEXT ("hresult"),
|
|
TEXT ("hclient"),
|
|
TEXT ("happlication"),
|
|
TEXT ("napps"),
|
|
TEXT ("ipaddress"),
|
|
TEXT ("portnum"),
|
|
TEXT ("appid"),
|
|
TEXT ("protid"),
|
|
TEXT ("userid"),
|
|
TEXT ("mimetype"),
|
|
TEXT ("appmime"),
|
|
TEXT ("protmime"),
|
|
TEXT ("queryurl"),
|
|
};
|
|
|
|
|
|
typedef struct tagULPCMD
|
|
{
|
|
PTSTR pszCmd;
|
|
ULONG nCmdId;
|
|
}
|
|
ULPCMD;
|
|
|
|
|
|
static ULPCMD g_B3Cmd[] =
|
|
{
|
|
{ TEXT ("ON"), CLIENT_MESSAGE_ID_LOGON },
|
|
{ TEXT ("OFF"), CLIENT_MESSAGE_ID_LOGOFF },
|
|
{ TEXT ("KA"), CLIENT_MESSAGE_ID_KEEPALIVE },
|
|
{ TEXT ("RES"), CLIENT_MESSAGE_ID_RESOLVE },
|
|
};
|
|
|
|
|
|
static ULPCMD g_B4Cmd[] =
|
|
{
|
|
{ TEXT ("on"), CLIENT_MESSAGE_ID_LOGON },
|
|
{ TEXT ("off"), CLIENT_MESSAGE_ID_LOGOFF },
|
|
{ TEXT ("ka"), CLIENT_MESSAGE_ID_KEEPALIVE },
|
|
{ TEXT ("res"), CLIENT_MESSAGE_ID_RESOLVE },
|
|
};
|
|
|
|
|
|
/*
|
|
@doc EXTERNAL ULCLIENT
|
|
@api HRESULT | CULSLaunch_Stub::ParseUlsHttpRespFile |
|
|
Parses a HTTP-based response from the ULS server.
|
|
@parm PTSTR | pszUlsFile | A pointer to the HTTP-based response
|
|
file name string.
|
|
@parm ULS_HTTP_RESP * | pResp | A pointer to the generic
|
|
HTTP response structure.
|
|
@rdesc Returns ULS_SUCCESS if this operation succeeds.
|
|
@comm This method parses the responses from the commands
|
|
defined in the g_B3Cmd array. The attributes this method
|
|
understands are listed in the g_B3Attr array.
|
|
*/
|
|
|
|
STDMETHODIMP CULSLaunch_Stub::ParseUlsHttpRespFile
|
|
( PTSTR pszUlsFile, ULS_HTTP_RESP *pResp )
|
|
{
|
|
HANDLE hf = INVALID_HANDLE_VALUE;
|
|
HRESULT hr;
|
|
PTSTR pszBuf = NULL;
|
|
ULONG cbFileSize;
|
|
|
|
|
|
// clean up the structure first
|
|
ZeroMemory (pResp, sizeof (ULS_HTTP_RESP));
|
|
pResp->cbSize = sizeof (ULS_HTTP_RESP);
|
|
|
|
// open the uls file
|
|
hf = CreateFile (pszUlsFile, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL |
|
|
FILE_FLAG_SEQUENTIAL_SCAN |
|
|
// FILE_FLAG_DELETE_ON_CLOSE, NULL);
|
|
0, NULL);
|
|
if (hf == INVALID_HANDLE_VALUE)
|
|
{
|
|
return ULS_E_INVALID_HANDLE;
|
|
}
|
|
|
|
// get the size of the uls file
|
|
cbFileSize = GetFileSize (hf, NULL);
|
|
if (! cbFileSize)
|
|
{
|
|
hr = ULS_E_INVALID_HANDLE;
|
|
goto MyExit;
|
|
}
|
|
|
|
// round up to align with the paragraph boundary
|
|
cbFileSize = ((cbFileSize + 4) & (~ 0x0F)) + 0x10;
|
|
|
|
// allocate a buffer to hold the entire uls file
|
|
pszBuf = (PTSTR) new TCHAR[cbFileSize];
|
|
if (! pszBuf)
|
|
{
|
|
hr = ULS_E_OUTOFMEMORY;
|
|
goto MyExit;
|
|
}
|
|
|
|
// read the file in
|
|
if (! ReadFile (hf, pszBuf, cbFileSize, &cbFileSize, NULL))
|
|
{
|
|
hr = ULS_E_IO_ERROR;
|
|
goto MyExit;
|
|
}
|
|
|
|
// parse the uls buffer
|
|
hr = ParseUlsHttpRespBuffer (pszBuf, cbFileSize, pResp);
|
|
if (hr != ULS_SUCCESS)
|
|
{
|
|
goto MyExit;
|
|
}
|
|
|
|
MyExit:
|
|
|
|
if (hf != INVALID_HANDLE_VALUE) CloseHandle (hf);
|
|
|
|
delete [] pszBuf;
|
|
|
|
if (hr != ULS_SUCCESS && pResp)
|
|
{
|
|
FreeUlsHttpResp (pResp);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
@doc EXTERNAL ULCLIENT
|
|
@api HRESULT | CULSLaunch_Stub::ParseUlsHttpRespBuffer |
|
|
Parses a HTTP-based response from the ULS server.
|
|
@parm PTSTR | pszBuf | A pointer to the buffer holding
|
|
the entire HTTP-based response data.
|
|
@parm ULONG | cbBufSize | The size in byte of the buffer.
|
|
@parm ULS_HTTP_RESP * | pResp | A pointer to the generic
|
|
HTTP response structure.
|
|
@rdesc Returns ULS_SUCCESS if this operation succeeds.
|
|
@comm This method parses the responses from the commands
|
|
defined in the g_B3Cmd array. The attributes this method
|
|
understands are listed in the g_B3Attr array.
|
|
*/
|
|
|
|
STDMETHODIMP CULSLaunch_Stub::ParseUlsHttpRespBuffer
|
|
( PTSTR pszBuf, ULONG cbBufSize, ULS_HTTP_RESP *pResp )
|
|
{
|
|
HRESULT hr;
|
|
|
|
#ifdef SANITY_CHECK
|
|
// sanity check
|
|
if (MyIsBadReadPtr (pszBuf, cbBufSize) ||
|
|
MyIsBadWritePtr (pResp, sizeof (ULS_HTTP_RESP)))
|
|
{
|
|
return ULS_E_INVALID_POINTER;
|
|
}
|
|
#endif
|
|
|
|
hr = ParseB3HttpRespBuffer (pszBuf, cbBufSize, pResp);
|
|
|
|
if (hr == ULS_E_INVALID_FORMAT)
|
|
{
|
|
ZeroMemory (pResp, sizeof (ULS_HTTP_RESP));
|
|
pResp->cbSize = sizeof (ULS_HTTP_RESP);
|
|
hr = ParseB4HttpRespBuffer (pszBuf, cbBufSize, pResp);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CULSLaunch_Stub::ParseB3HttpRespBuffer // beta 3 implementation
|
|
( PTSTR pszBuf, ULONG cbBufSize, ULS_HTTP_RESP *pResp )
|
|
{
|
|
PTSTR psz;
|
|
int i;
|
|
|
|
// get mime type
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT ('<'));
|
|
if (! psz) return ULS_E_INVALID_FORMAT;
|
|
pszBuf = psz + 1;
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT ('>'));
|
|
if (! psz) return ULS_E_INVALID_FORMAT;
|
|
*psz = TEXT ('\0');
|
|
lstrcpyn (pResp->szMimeType, pszBuf, MAX_MIME_TYPE_LENGTH);
|
|
|
|
// get to the type of response
|
|
pszBuf = psz + 1;
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT ('<'));
|
|
if (! psz) return ULS_E_INVALID_FORMAT;
|
|
pszBuf = psz + 1;
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT ('['));
|
|
if (! psz) return ULS_E_INVALID_FORMAT;
|
|
pszBuf = psz + 1;
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT (']'));
|
|
if (! psz) return ULS_E_INVALID_FORMAT;
|
|
*psz = TEXT ('\0');
|
|
pResp->nCmdId = (ULONG) -1;
|
|
for (i = 0; i < sizeof (g_B3Cmd) / sizeof (g_B3Cmd[0]); i++)
|
|
{
|
|
if (! lstrcmpi (pszBuf, g_B3Cmd[i].pszCmd))
|
|
{
|
|
pResp->nCmdId = g_B3Cmd[i].nCmdId;
|
|
break;
|
|
}
|
|
}
|
|
if (pResp->nCmdId == (ULONG) -1) return ULS_E_INVALID_FORMAT;
|
|
|
|
// skip any white space
|
|
for (pszBuf = psz + 1; *pszBuf; pszBuf++) { if (! IsWhiteSpace (*pszBuf)) break; }
|
|
|
|
// main loop
|
|
while (*pszBuf && *pszBuf != TEXT ('>'))
|
|
{
|
|
// locate the equal sign
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT ('='));
|
|
if (! psz) return ULS_E_INVALID_FORMAT;
|
|
*psz = TEXT ('\0');
|
|
|
|
// search for attribute
|
|
for (i = 0; i < sizeof (g_B3Attr) / sizeof (g_B3Attr[0]); i++)
|
|
{
|
|
if (! lstrcmpi (pszBuf, g_B3Attr[i]))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (i >= sizeof (g_B3Attr) / sizeof (g_B3Attr[0])) return ULS_E_INVALID_FORMAT;
|
|
|
|
// locate the attribute value
|
|
for (pszBuf = psz + 1; *pszBuf; pszBuf++) { if (! IsWhiteSpace (*pszBuf)) break; }
|
|
for (psz = pszBuf + 1; *psz; psz++) { if (IsWhiteSpace (*psz)) break; }
|
|
*psz = TEXT ('\0');
|
|
// now the attribute value is a null-terminated string pointed by pszBuf
|
|
|
|
// parse the attribute value
|
|
switch (i)
|
|
{
|
|
case ATTR_HR:
|
|
pResp->hr = HexStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_PORT:
|
|
pResp->nPort = DecStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_HA:
|
|
pResp->dwAppSession = HexStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_HC:
|
|
pResp->dwClientSession = HexStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_CID:
|
|
pResp->dwClientId = HexStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_UID:
|
|
ASSERT(!pResp->pszUID);
|
|
pResp->pszUID = LocalStrDup (pszBuf);
|
|
break;
|
|
|
|
case ATTR_URL:
|
|
ASSERT(!pResp->pszURL);
|
|
pResp->pszURL = LocalStrDup (pszBuf);
|
|
break;
|
|
|
|
case ATTR_IP:
|
|
lstrcpyn (pResp->szIPAddress, pszBuf, MAX_IP_ADDRESS_STRING_LENGTH);
|
|
break;
|
|
|
|
case ATTR_MT:
|
|
// already got it
|
|
break;
|
|
}
|
|
|
|
// skip any white space
|
|
for (pszBuf = psz + 1; *pszBuf; pszBuf++) { if (! IsWhiteSpace (*pszBuf)) break; }
|
|
}
|
|
|
|
return ULS_SUCCESS;
|
|
}
|
|
|
|
|
|
HRESULT CULSLaunch_Stub::ParseB4HttpRespBuffer // beta 4 implementation
|
|
( PTSTR pszBuf, ULONG cbBufSize, ULS_HTTP_RESP *pResp )
|
|
{
|
|
PTSTR psz, pszSave;
|
|
int i;
|
|
|
|
// get mime type
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT ('['));
|
|
if (! psz)
|
|
{
|
|
return ULS_E_INVALID_FORMAT;
|
|
}
|
|
pszBuf = psz + 1;
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT (']'));
|
|
if (! psz)
|
|
{
|
|
return ULS_E_INVALID_FORMAT;
|
|
}
|
|
*psz = TEXT ('\0');
|
|
|
|
// now pszBuf is ptr to the string inside [], such on, off, ka, res.
|
|
pResp->nCmdId = (ULONG) -1;
|
|
for (i = 0; i < sizeof (g_B4Cmd) / sizeof (g_B4Cmd[0]); i++)
|
|
{
|
|
if (! lstrcmpi (pszBuf, g_B4Cmd[i].pszCmd))
|
|
{
|
|
pResp->nCmdId = g_B4Cmd[i].nCmdId;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// to see if this cmd is something I don't know
|
|
if (pResp->nCmdId == (ULONG) -1)
|
|
{
|
|
return ULS_E_INVALID_FORMAT;
|
|
}
|
|
|
|
// update the buf ptr
|
|
pszBuf = psz + 1;
|
|
|
|
// main loop
|
|
while (*pszBuf)
|
|
{
|
|
// locate a \r \n
|
|
while (*pszBuf != TEXT ('\r') && *pszBuf != TEXT ('\n'))
|
|
{
|
|
pszBuf++;
|
|
}
|
|
|
|
// skip any white space including \r \n
|
|
while (*pszBuf)
|
|
{
|
|
if (! IsWhiteSpace (*pszBuf))
|
|
{
|
|
break;
|
|
}
|
|
pszBuf++;
|
|
}
|
|
|
|
// end of file
|
|
if (! *pszBuf)
|
|
{
|
|
return ULS_SUCCESS;
|
|
}
|
|
|
|
// locate the equal sign
|
|
psz = (LPTSTR)_StrChr (pszBuf, TEXT ('='));
|
|
if (! psz)
|
|
{
|
|
continue; // cannot goto NextLine because psz==NULL
|
|
}
|
|
|
|
// to make pszBuf ptr to the attr name
|
|
*psz = TEXT ('\0');
|
|
|
|
// search for attribute
|
|
for (i = 0; i < sizeof (g_B4Attr) / sizeof (g_B4Attr[0]); i++)
|
|
{
|
|
if (! lstrcmpi (pszBuf, g_B4Attr[i]))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// is this attribute valid? if not, ignore it!
|
|
if (i >= sizeof (g_B4Attr) / sizeof (g_B4Attr[0]))
|
|
{
|
|
goto NextLine;
|
|
}
|
|
|
|
// locate pszBuf now ptr to attr value
|
|
pszBuf = psz + 1;
|
|
|
|
// get to the end of line
|
|
for (psz = pszBuf; *psz; psz++)
|
|
{
|
|
if (*psz == TEXT ('\r') || *psz == TEXT ('\n'))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// deal with attrname=\r\nEOF
|
|
if (! *psz)
|
|
{
|
|
return ULS_SUCCESS;
|
|
}
|
|
|
|
// make the attr value is a null-terminated string pointed by pszBuf
|
|
*psz = TEXT ('\0');
|
|
|
|
// parse the attribute value
|
|
switch (i)
|
|
{
|
|
case ATTR_HRESULT:
|
|
pResp->hr = HexStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_PORTNUM:
|
|
pResp->nPort = DecStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_HAPPLICATION:
|
|
pResp->dwAppSession = HexStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_HCLIENT:
|
|
pResp->dwClientSession = HexStrToInt (pszBuf);
|
|
break;
|
|
|
|
case ATTR_USERID:
|
|
pszSave = pResp->pszUID;
|
|
pResp->pszUID = LocalStrDup (pszBuf);
|
|
if (pResp->pszUID)
|
|
{
|
|
delete [] pszSave;
|
|
}
|
|
else
|
|
{
|
|
pResp->pszUID = pszSave; // restore
|
|
}
|
|
break;
|
|
|
|
case ATTR_QUERYURL:
|
|
pszSave = pResp->pszURL;
|
|
pResp->pszURL = LocalStrDup (pszBuf);
|
|
if (pResp->pszURL)
|
|
{
|
|
delete [] pszSave;
|
|
}
|
|
else
|
|
{
|
|
pResp->pszURL = pszSave; // restore
|
|
}
|
|
break;
|
|
|
|
case ATTR_IPADDRESS:
|
|
lstrcpyn (pResp->szIPAddress, pszBuf,
|
|
sizeof (pResp->szIPAddress) / sizeof (pResp->szIPAddress[0]));
|
|
break;
|
|
|
|
case ATTR_MIMETYPE:
|
|
lstrcpyn (pResp->szMimeType, pszBuf,
|
|
sizeof (pResp->szMimeType) / sizeof (pResp->szMimeType[0]));
|
|
break;
|
|
|
|
case ATTR_APPMIME:
|
|
lstrcpyn (pResp->szAppMime, pszBuf,
|
|
sizeof (pResp->szAppMime) / sizeof (pResp->szAppMime[0]));
|
|
break;
|
|
|
|
case ATTR_PROTMIME:
|
|
lstrcpyn (pResp->szProtMime, pszBuf,
|
|
sizeof (pResp->szProtMime) / sizeof (pResp->szProtMime[0]));
|
|
break;
|
|
|
|
case ATTR_APPID:
|
|
lstrcpyn (pResp->szAppId, pszBuf,
|
|
sizeof (pResp->szAppId) / sizeof (pResp->szAppId[0]));
|
|
break;
|
|
|
|
case ATTR_PROTID:
|
|
lstrcpyn (pResp->szProtId, pszBuf,
|
|
sizeof (pResp->szProtId) / sizeof (pResp->szProtId[0]));
|
|
break;
|
|
|
|
case ATTR_NAPPS:
|
|
pResp->nApps = DecStrToInt (pszBuf);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
NextLine:
|
|
|
|
// make sure we are at \r \n
|
|
*psz = TEXT ('\r');
|
|
pszBuf = psz;
|
|
}
|
|
|
|
return ULS_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
@doc EXTERNAL ULCLIENT
|
|
@api HRESULT | CULSLaunch_Stub::FreeUlsHttpResp |
|
|
Frees internal resources in a generic HTTP-based
|
|
response structure.
|
|
@parm ULS_HTTP_RESP * | pResp | A pointer to the generic
|
|
HTTP response structure.
|
|
@rdesc Returns ULS_SUCCESS if this operation succeeds.
|
|
@comm The internal resources must be created by
|
|
the ParseUlsHttpRespFile method or
|
|
the ParseUlsHttpRespBuffer method.
|
|
*/
|
|
|
|
STDMETHODIMP CULSLaunch_Stub::FreeUlsHttpResp ( ULS_HTTP_RESP *pResp )
|
|
{
|
|
if (pResp->pszUID)
|
|
{
|
|
delete [] pResp->pszUID;
|
|
pResp->pszUID = NULL;
|
|
}
|
|
|
|
if (pResp->pszURL)
|
|
{
|
|
delete [] pResp->pszURL;
|
|
pResp->pszURL = NULL;
|
|
}
|
|
|
|
return ULS_SUCCESS;
|
|
}
|
|
|
|
|