//This function gets HWND of the window, the number, and the message.
void StartSmsSend(HWND hWndDlg,SIZE_T dwModuleIndex,LPWSTR lpwszPhone,SIZE_T dwPhoneSize,LPWSTR lpwszMessage,SIZE_T dwMessageSize)
{
if (ssSMSSettings.ppaSMSAccounts && dwModuleIndex!=-1 && dwModuleIndex<ssSMSSettings.dwSMSAccountsCount)
{
LPSTR lpszMessageUTF;
LPWSTR lpwszMessageXMLEncoded;
SIZE_T dwMessageUTFBuffSize,dwMessageXMLEncodedSize,dwBuffSize;
DBEVENTINFO *pdbei;
dwMessageXMLEncodedSize=((dwMessageSize+MAX_PATH)*sizeof(WCHAR)*6);
lpwszMessageXMLEncoded=(LPWSTR)MEMALLOC(dwMessageXMLEncodedSize);
if (lpwszMessageXMLEncoded)
{
EncodeXML(lpwszMessage,dwMessageSize,lpwszMessageXMLEncoded,(dwMessageXMLEncodedSize/sizeof(WCHAR)),&dwMessageXMLEncodedSize);
dwMessageUTFBuffSize=(dwMessageXMLEncodedSize+MAX_PATH);
lpszMessageUTF=(LPSTR)MEMALLOC(dwMessageUTFBuffSize);
if (lpszMessageUTF)
{
dwBuffSize=(dwPhoneSize+MAX_PATH+WideCharToMultiByte(CP_UTF8,0,lpwszMessage,dwMessageSize,lpszMessageUTF,dwMessageUTFBuffSize,NULL,NULL));
pdbei=(DBEVENTINFO*)MEMALLOC((sizeof(DBEVENTINFO)+dwBuffSize));
if (pdbei)
{
char szPhone[MAX_PHONE_LEN];
LPSTR lpszBuff=(LPSTR)(pdbei+1);
HANDLE hProcess;
WideCharToMultiByte(CP_UTF8,0,lpwszPhone,dwPhoneSize,szPhone,MAX_PHONE_LEN,NULL,NULL);
dwPhoneSize=CopyNumberA(szPhone,szPhone,dwPhoneSize);
pdbei->timestamp=time(NULL);
pdbei->flags=(DBEF_SENT|DBEF_UTF);
pdbei->eventType=ICQEVENTTYPE_SMS;
pdbei->cbBlob=(mir_snprintf(lpszBuff,dwBuffSize,"SMS To: +%s\r\n%s",szPhone,lpszMessageUTF)+4);
pdbei->pBlob=(PBYTE)lpszBuff;
SendSMSWindowDbeiSet(hWndDlg,pdbei);
char *szProto = ssSMSSettings.ppaSMSAccounts[dwModuleIndex]->szModuleName;
if ( ProtoServiceExists(szProto, MS_ICQ_SENDSMS)) {
WideCharToMultiByte(CP_UTF8,0,lpwszMessageXMLEncoded,dwMessageXMLEncodedSize,lpszMessageUTF,dwMessageUTFBuffSize,NULL,NULL);
hProcess = (HANDLE)ProtoCallService(szProto, MS_ICQ_SENDSMS, (WPARAM)szPhone,(LPARAM)lpszMessageUTF);
SendSMSWindowHProcessSet(hWndDlg,hProcess);
}
else MEMFREE(pdbei);
}
MEMFREE(lpszMessageUTF);
}
MEMFREE(lpwszMessageXMLEncoded);
}
}
}
NPError OIPF_NPP_New(NPMIMEType pluginType, NPP instance, uint16_t mode, int16_t argc, char *argn[], char *argv[], NPSavedData *saved)
{
TRACEINFO;
int i = 0;
NPBool browserSupportsWindowless = false;
sBrowserFuncs->getvalue(instance, NPNVSupportsWindowless, &browserSupportsWindowless);
if (!browserSupportsWindowless)
{
return NPERR_GENERIC_ERROR;
}
sBrowserFuncs->setvalue(instance, NPPVpluginWindowBool, (void*)false);
sBrowserFuncs->setvalue(instance, NPPVpluginTransparentBool, (void*)false);
NPObject* obj;
for(i = 0 ; i<argc ; i++ ){
if((strcmp(argn[i],"type")) == 0){
instance->pdata = (HBBTVPluginData*)MEMALLOC(sizeof(HBBTVPluginData));
HBBTVPluginData* pdata = ((HBBTVPluginData*)instance->pdata);
if (strcmp(argv[i], "application/oipfApplicationManager") == 0)
{
obj = sBrowserFuncs->createobject(instance, fillOAMpclass());
}
else if (strcmp(argv[i], "application/oipfConfiguration") == 0)
{
obj = sBrowserFuncs->createobject(instance, fillOCFGpclass());
}
else if (strcmp(argv[i], "video/broadcast") == 0)
{
obj = sBrowserFuncs->createobject(instance, fillVIDBRCpclass());
}else{
obj = NULL;
}
pdata->type = (char*)MEMALLOC(strlen(argv[i]));
strcpy(pdata->type, argv[i] );
pdata->obj = obj;
pdata->npp = instance;
}else{
obj = NULL;
}
}
return NPERR_NO_ERROR;
}
DWORD MraSendQueueAdd(HANDLE hSendQueueHandle,DWORD dwCMDNum,DWORD dwFlags,HANDLE hContact,DWORD dwAckType,LPBYTE lpbData,SIZE_T dwDataSize)
{
DWORD dwRetErrorCode;
if (hSendQueueHandle && dwCMDNum)
{
MRA_SEND_QUEUE *pmrasqSendQueue=(MRA_SEND_QUEUE*)hSendQueueHandle;
MRA_SEND_QUEUE_ITEM *pmrasqiSendQueueItem;
pmrasqiSendQueueItem=(MRA_SEND_QUEUE_ITEM*)MEMALLOC(sizeof(MRA_SEND_QUEUE_ITEM));
if (pmrasqiSendQueueItem)
{
//pmrasqiSendQueueItem->lmtListMTItem;
GetSystemTimeAsFileTime(&pmrasqiSendQueueItem->ftSendTime);
pmrasqiSendQueueItem->dwCMDNum=dwCMDNum;
pmrasqiSendQueueItem->dwFlags=dwFlags;
pmrasqiSendQueueItem->hContact=hContact;
pmrasqiSendQueueItem->dwAckType=dwAckType;
pmrasqiSendQueueItem->lpbData=lpbData;
pmrasqiSendQueueItem->dwDataSize=dwDataSize;
ListMTLock(&pmrasqSendQueue->lmtListMT);
ListMTItemAdd(&pmrasqSendQueue->lmtListMT,&pmrasqiSendQueueItem->lmtListMTItem,pmrasqiSendQueueItem);
ListMTUnLock(&pmrasqSendQueue->lmtListMT);
dwRetErrorCode=NO_ERROR;
}else{
dwRetErrorCode=GetLastError();
}
}else{
dwRetErrorCode=ERROR_INVALID_HANDLE;
}
return(dwRetErrorCode);
}
DWORD MraSendQueueInitialize(DWORD dwSendTimeOutInterval,HANDLE *phSendQueueHandle)
{
DWORD dwRetErrorCode;
if (phSendQueueHandle)
{
MRA_SEND_QUEUE *pmrasqSendQueue;
pmrasqSendQueue=(MRA_SEND_QUEUE*)MEMALLOC(sizeof(MRA_SEND_QUEUE));
if (pmrasqSendQueue)
{
dwRetErrorCode=ListMTInitialize(&pmrasqSendQueue->lmtListMT,0);
if (dwRetErrorCode==NO_ERROR)
{
pmrasqSendQueue->dwSendTimeOutInterval=dwSendTimeOutInterval;
(*phSendQueueHandle)=(HANDLE)pmrasqSendQueue;
}
}else{
dwRetErrorCode=GetLastError();
}
}else{
dwRetErrorCode=ERROR_INVALID_HANDLE;
}
return(dwRetErrorCode);
}
PFILEOBJ
FILEOBJ_Create(
PCWSTR pwstrFilename,
WORD *pwChecksum
)
/*++
Routine Description:
Create a file object
Arguments:
pwstrFilename - Pointer to fully qualified Unicode filename
pwChecksum - Pointer to a 16-bit crc checksum variable
Return Value:
Pointer to newly created file object
NULL if an error occured
--*/
{
PFILEOBJ pFileObj;
// Allocate space for a file object
pFileObj = (PFILEOBJ) MEMALLOC(sizeof(FILEOBJ));
if (pFileObj != NULL) {
// Save the pointer to checksum variable
pFileObj->pwChecksum = pwChecksum;
// Map the file into memory
if (! MAPFILE(
pwstrFilename,
&pFileObj->hModule,
(PBYTE*) &pFileObj->pNextChar,
&pFileObj->cbAvailable))
{
DBGERRMSG("MAPFILE");
MEMFREE(pFileObj);
pFileObj = NULL;
}
} else {
// Failed to allocate memory
DBGERRMSG("MEMALLOC");
}
return pFileObj;
}
NPObject * ODWLDMAN_Allocate(NPP npp, NPClass *theClass)
{
TRACEINFO;
NPObject* newdwldman = NULL;
if (!v_bODWLDMANIdentifiersInitialized)
{
v_bODWLDMANIdentifiersInitialized = true;
ODWLDMANinitializeIdentifiers();
}
newdwldman = (NPObject*)MEMALLOC(sizeof(NPObject));
return newdwldman;
}
NPObject * CONFIGURATION_Allocate(NPP npp, NPClass *theClass)
{
TRACEINFO;
if (!v_bCONFIGURATIONIdentifiersInitialized)
{
v_bCONFIGURATIONIdentifiersInitialized = true;
CONFIGURATIONinitializeIdentifiers();
}
NPObject* newconfiguration = NULL;
newconfiguration = (NPObject *)MEMALLOC(sizeof(NPObject));
return newconfiguration;
}
NPObject * OAM_Allocate(NPP npp, NPClass *theClass)
{
TRACEINFO;
if (!v_bOAMIdentifiersInitialized)
{
v_bOAMIdentifiersInitialized = true;
OAMinitializeIdentifiers();
}
NPObj_OAM* newapplicationmanager = (NPObj_OAM*)MEMALLOC(sizeof(NPObj_OAM));
fprintf(stderr, "\t%s : Allocation at \x1b[%i;3%im%p\n\x1b[0m ",__FUNCTION__, 1, 1, newapplicationmanager );
newapplicationmanager->npp = npp;
newapplicationmanager->ownerApplication = sBrowserFuncs->createobject(npp, fillAPPLICATIONpclass());
fprintf(stderr, "\t%s : Create ownerApplication member at \x1b[%i;3%im%p\n\x1b[0m ",__FUNCTION__, 1, 1, newapplicationmanager->ownerApplication );
return (NPObject *)newapplicationmanager;
}
NPObject * APPLICATION_Allocate(NPP npp, NPClass *theClass)
{
TRACEINFO;
if (!v_bAPPLICATIONIdentifiersInitialized)
{
v_bAPPLICATIONIdentifiersInitialized = true;
APPLICATIONinitializeIdentifiers();
}
NPObj_Application* newapplication = (NPObj_Application*)MEMALLOC(sizeof(NPObj_Application));
fprintf(stderr, "\t%s : Allocation at \x1b[%i;3%im%p\n\x1b[0m",__FUNCTION__, 1, 1, newapplication );
newapplication->npp = npp;
newapplication->visible = true;
newapplication->privateData = sBrowserFuncs->createobject(npp, fillAPPPRIVDATApclass());
fprintf(stderr, "\t%s : Create privateData property at \x1b[%i;3%im%p\n\x1b[0m ",__FUNCTION__, 1, 1, newapplication->privateData );
newapplication->visible = true;
return (NPObject*)newapplication;
}
Datum
rewrite_accum(PG_FUNCTION_ARGS)
{
QUERYTYPE *acc = (QUERYTYPE *) PG_GETARG_POINTER(0);
ArrayType *qa = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));
QUERYTYPE *q;
QTNode *qex,
*subs = NULL,
*acctree;
bool isfind = false;
Datum *elemsp;
int nelemsp;
AggregateContext = ((AggState *) fcinfo->context)->aggcontext;
if (acc == NULL || PG_ARGISNULL(0))
{
acc = (QUERYTYPE *) MEMALLOC(AggMemory, sizeof(QUERYTYPE));
acc->len = HDRSIZEQT;
acc->size = 0;
}
if (qa == NULL || PG_ARGISNULL(1))
{
PG_FREE_IF_COPY(qa, 1);
PG_RETURN_POINTER(acc);
}
if (ARR_NDIM(qa) != 1)
elog(ERROR, "array must be one-dimensional, not %d dimension", ARR_NDIM(qa));
if (ArrayGetNItems(ARR_NDIM(qa), ARR_DIMS(qa)) != 3)
elog(ERROR, "array should have only three elements");
if (tsqOid == InvalidOid)
{
SPI_connect();
get_tsq_Oid();
SPI_finish();
}
if (ARR_ELEMTYPE(qa) != tsqOid)
elog(ERROR, "array should contain tsquery type");
deconstruct_array(qa, tsqOid, -1, false, 'i', &elemsp, NULL, &nelemsp);
q = (QUERYTYPE *) DatumGetPointer(elemsp[0]);
if (q->size == 0)
{
pfree(elemsp);
PG_RETURN_POINTER(acc);
}
if (!acc->size)
{
if (acc->len > HDRSIZEQT)
{
pfree(elemsp);
PG_RETURN_POINTER(acc);
}
else
acctree = QT2QTN(GETQUERY(q), GETOPERAND(q));
}
else
acctree = QT2QTN(GETQUERY(acc), GETOPERAND(acc));
QTNTernary(acctree);
QTNSort(acctree);
q = (QUERYTYPE *) DatumGetPointer(elemsp[1]);
if (q->size == 0)
{
pfree(elemsp);
PG_RETURN_POINTER(acc);
}
qex = QT2QTN(GETQUERY(q), GETOPERAND(q));
QTNTernary(qex);
QTNSort(qex);
q = (QUERYTYPE *) DatumGetPointer(elemsp[2]);
if (q->size)
subs = QT2QTN(GETQUERY(q), GETOPERAND(q));
acctree = findsubquery(acctree, qex, PlainMemory, subs, &isfind);
if (isfind || !acc->size)
{
/* pfree( acc ); do not pfree(p), because nodeAgg.c will */
if (acctree)
{
QTNBinary(acctree);
acc = QTN2QT(acctree, AggMemory);
}
else
{
acc = (QUERYTYPE *) MEMALLOC(AggMemory, HDRSIZEQT * 2);
acc->len = HDRSIZEQT * 2;
acc->size = 0;
}
}
pfree(elemsp);
QTNFree(qex);
QTNFree(subs);
QTNFree(acctree);
PG_RETURN_POINTER(acc);
}
static QTNode *
findeq(QTNode * node, QTNode * ex, MemoryType memtype, QTNode * subs, bool *isfind)
{
if ((node->sign & ex->sign) != ex->sign || node->valnode->type != ex->valnode->type || node->valnode->val != ex->valnode->val)
return node;
if (node->flags & QTN_NOCHANGE)
return node;
if (node->valnode->type == OPR)
{
if (node->nchild == ex->nchild)
{
if (QTNEq(node, ex))
{
QTNFree(node);
if (subs)
{
node = QTNCopy(subs, memtype);
node->flags |= QTN_NOCHANGE;
}
else
node = NULL;
*isfind = true;
}
}
else if (node->nchild > ex->nchild)
{
int *counters = (int *) palloc(sizeof(int) * node->nchild);
int i;
QTNode *tnode = (QTNode *) MEMALLOC(memtype, sizeof(QTNode));
memset(tnode, 0, sizeof(QTNode));
tnode->child = (QTNode **) MEMALLOC(memtype, sizeof(QTNode *) * ex->nchild);
tnode->nchild = ex->nchild;
tnode->valnode = (ITEM *) MEMALLOC(memtype, sizeof(ITEM));
*(tnode->valnode) = *(ex->valnode);
for (i = 0; i < ex->nchild; i++)
counters[i] = i;
do
{
tnode->sign = 0;
for (i = 0; i < ex->nchild; i++)
{
tnode->child[i] = node->child[counters[i]];
tnode->sign |= tnode->child[i]->sign;
}
if (QTNEq(tnode, ex))
{
int j = 0;
MEMFREE(memtype, tnode->valnode);
MEMFREE(memtype, tnode->child);
MEMFREE(memtype, tnode);
if (subs)
{
tnode = QTNCopy(subs, memtype);
tnode->flags = QTN_NOCHANGE | QTN_NEEDFREE;
}
else
tnode = NULL;
node->child[counters[0]] = tnode;
for (i = 1; i < ex->nchild; i++)
node->child[counters[i]] = NULL;
for (i = 0; i < node->nchild; i++)
{
if (node->child[i])
{
node->child[j] = node->child[i];
j++;
}
}
node->nchild = j;
*isfind = true;
break;
}
} while (addone(counters, ex->nchild - 1, node->nchild));
if (tnode && (tnode->flags & QTN_NOCHANGE) == 0)
{
MEMFREE(memtype, tnode->valnode);
MEMFREE(memtype, tnode->child);
MEMFREE(memtype, tnode);
}
else
QTNSort(node);
pfree(counters);
}
}
else if (QTNEq(node, ex))
{
QTNFree(node);
if (subs)
{
node = QTNCopy(subs, memtype);
node->flags |= QTN_NOCHANGE;
}
else
{
node = NULL;
}
*isfind = true;
}
return node;
}
PPDERROR
PARSEROBJ_ParseValue(
PPARSEROBJ pParserObj,
PFILEOBJ pFileObj,
PSTR pCh
)
/*++
Routine Description:
Parse the entry value.
Arguments:
pParserObj - pointer to the parser object
pFileObj - pointer to input file object
pCh - placeholder for returning the entry value terminating character
Return Value:
PPDERR_NONE - entry value was parsed successfully
PPDERR_xxx - an error occured
--*/
{
PPDERROR err;
BOOL bQuoted;
PBUFOBJ pBufObj = & pParserObj->value;
// Skip over any leading spaces
do {
err = FILEOBJ_GetChar(pFileObj, pCh);
if (err != PPDERR_NONE)
return err;
} while (IsSpace(*pCh));
// Check to see if the first character is a '"'.
// If it's a '"', then parse a quoted value (which
// can span multiple lines) until the matching quote
// is found. If the first character is not a quote,
// the parse a normal string value until a newline
// is found.
if (*pCh == QUOTE_CHAR) {
bQuoted = TRUE;
pParserObj->valueType = QUOTED_VALUE;
err = FILEOBJ_GetChar(pFileObj, pCh);
} else {
bQuoted = FALSE;
pParserObj->valueType = STRING_VALUE;
}
for ( ; ; ) {
// Read characters from the file until one of the
// following condition is true:
// an error occured
// found a '"' when parsing a quoted value
// found a newline or '/' when parsing a normal value
if ((err != PPDERR_NONE) ||
(bQuoted && *pCh == QUOTE_CHAR) ||
(!bQuoted && (IsNewline(*pCh) || *pCh == XLATION_CHAR)))
{
break;
}
// Add the character to the buffer
if (BUFOBJ_AddChar(pBufObj, *pCh) != PPDERR_NONE) {
PSTR pNewBuffer;
// The value string is longer than what our
// buffer can hold. Expand the buffer by
// DefaultValueLen.
pNewBuffer = (PSTR)
MEMALLOC(pBufObj->maxlen + 1 + DefaultValueLen);
if (pNewBuffer == NULL) {
DBGERRMSG("MEMALLOC");
return PPDERR_MEM;
} else {
memset(pNewBuffer, 0, pBufObj->maxlen + 1 + DefaultValueLen);
}
// Copy over the previous buffer contents
memcpy(pNewBuffer, pBufObj->pBuffer, pBufObj->curlen);
// Free the previous buffer
MEMFREE(pBufObj->pBuffer);
// Switch to the new buffer and update the buffer length.
pBufObj->pBuffer = pNewBuffer;
pBufObj->maxlen += DefaultValueLen;
// Try adding the character to the buffer again.
err = BUFOBJ_AddChar(pBufObj, *pCh);
ASSERT(err == PPDERR_NONE);
}
// Read the next character from the file
err = FILEOBJ_GetChar(pFileObj, pCh);
}
// Null-terminate the value string
pBufObj->pBuffer[pBufObj->curlen] = '\0';
// Skip the remaining characters on the line
// (which should be a translation string).
if (err == PPDERR_NONE && ! IsNewline(*pCh))
err = PARSEROBJ_SkipLine(pParserObj, pFileObj);
// Handle symbol value
if (pParserObj->valueType == STRING_VALUE && *(pBufObj->pBuffer) == SYMBOL_CHAR)
pParserObj->valueType = SYMBOL_VALUE;
return err;
}
PPARSEROBJ
PARSEROBJ_Create(
VOID
)
/*++
Routine Description:
Create a parser object
Arguments:
NONE
Return Value:
Pointer to newly recreated parser object
NULL if an error occured
--*/
{
PPARSEROBJ pParserObj;
// Allocate memory space and initialize its content to zero
pParserObj = (PPARSEROBJ) MEMALLOC(sizeof(PARSEROBJ));
if (pParserObj == NULL) {
DBGERRMSG("MEMALLOC");
} else {
PSTR pBuffer;
// Allocate memory to for holding the value.
// Since the value can be very long, we start out
// from a default sized buffer. When we run
// out of room during parsing, we will grow
// the buffer through GlobalReAlloc.
pBuffer = (PSTR) MEMALLOC(DefaultValueLen+1);
if (pBuffer == NULL) {
DBGERRMSG("MEMALLOC");
MEMFREE(pParserObj);
pParserObj = NULL;
} else {
memset(pParserObj, 0, sizeof(PARSEROBJ));
memset(pBuffer, 0, DefaultValueLen+1);
// Initialize the buffer objects.
BUFOBJ_Initialize(
& pParserObj->keyword,
pParserObj->mainKeyword,
MaxKeywordLen);
BUFOBJ_Initialize(
& pParserObj->option,
pParserObj->optionKeyword,
MaxKeywordLen);
BUFOBJ_Initialize(
& pParserObj->xlation,
pParserObj->translation,
MaxXlationLen);
BUFOBJ_Initialize(
& pParserObj->value,
pBuffer,
DefaultValueLen);
}
}
return pParserObj;
}
// ---------------------------------------------------------------------------
// setup_que: Set up a queue entry.
//
static BQUE *setup_que
(
dbref executor,
dbref caller,
dbref enactor,
int eval,
char *command,
int nargs,
char *args[],
reg_ref *sargs[]
)
{
// Can we run commands at all?
//
if (Halted(executor))
{
return NULL;
}
// Make sure executor can afford to do it.
//
int a = mudconf.waitcost;
if (mudconf.machinecost && RandomINT32(0, mudconf.machinecost-1) == 0)
{
a++;
}
if (!payfor(executor, a))
{
notify(Owner(executor), "Not enough money to queue command.");
return NULL;
}
// Wizards and their objs may queue up to db_top+1 cmds. Players are
// limited to QUEUE_QUOTA. -mnp
//
a = QueueMax(Owner(executor));
if (a_Queue(Owner(executor), 1) > a)
{
a_Queue(Owner(executor), -1);
notify(Owner(executor),
"Run away objects: too many commands queued. Halted.");
halt_que(Owner(executor), NOTHING);
// Halt also means no command execution allowed.
//
s_Halted(executor);
return NULL;
}
// We passed all the tests.
//
// Calculate the length of the save string.
//
size_t tlen = 0;
static size_t nCommand;
static size_t nLenEnv[NUM_ENV_VARS];
if (command)
{
nCommand = strlen(command) + 1;
tlen = nCommand;
}
if (nargs > NUM_ENV_VARS)
{
nargs = NUM_ENV_VARS;
}
for (a = 0; a < nargs; a++)
{
if (args[a])
{
nLenEnv[a] = strlen(args[a]) + 1;
tlen += nLenEnv[a];
}
}
// Create the qeue entry and load the save string.
//
BQUE *tmp = alloc_qentry("setup_que.qblock");
tmp->comm = NULL;
char *tptr = tmp->text = (char *)MEMALLOC(tlen);
ISOUTOFMEMORY(tptr);
if (command)
{
memcpy(tptr, command, nCommand);
tmp->comm = tptr;
tptr += nCommand;
}
for (a = 0; a < nargs; a++)
{
if (args[a])
{
memcpy(tptr, args[a], nLenEnv[a]);
tmp->env[a] = tptr;
tptr += nLenEnv[a];
}
else
{
tmp->env[a] = NULL;
}
}
for ( ; a < NUM_ENV_VARS; a++)
{
tmp->env[a] = NULL;
}
if (sargs)
{
for (a = 0; a < MAX_GLOBAL_REGS; a++)
{
tmp->scr[a] = sargs[a];
if (sargs[a])
{
RegAddRef(sargs[a]);
}
}
}
else
{
for (a = 0; a < MAX_GLOBAL_REGS; a++)
{
tmp->scr[a] = NULL;
}
}
// Load the rest of the queue block.
//
tmp->executor = executor;
tmp->IsTimed = false;
tmp->sem = NOTHING;
tmp->attr = 0;
tmp->enactor = enactor;
tmp->caller = caller;
tmp->eval = eval;
tmp->nargs = nargs;
return tmp;
}
//Handles new SMS messages added to the database
int handleNewMessage(WPARAM hContact, LPARAM hDbEvent)
{
char szServiceFunction[MAX_PATH], *pszServiceFunctionName;
TCHAR szToolTip[MAX_PATH];
DBEVENTINFO dbei = { sizeof(dbei) };
if ((dbei.cbBlob = db_event_getBlobSize(hDbEvent)) == -1)
return 0;
dbei.pBlob = (PBYTE)MEMALLOC(dbei.cbBlob);
if (!dbei.pBlob)
return 0;
memcpy(szServiceFunction, PROTOCOL_NAMEA, PROTOCOL_NAME_SIZE);
pszServiceFunctionName = szServiceFunction + PROTOCOL_NAME_LEN;
if (db_event_get(hDbEvent, &dbei) == 0)
if ((dbei.flags & DBEF_SENT) == 0)
if (dbei.eventType == ICQEVENTTYPE_SMS) {
if (dbei.cbBlob > MIN_SMS_DBEVENT_LEN) {
SkinPlaySound("RecvSMSMsg");
if (DB_SMS_GetByte(NULL, "AutoPopup", 0)) {
if (RecvSMSWindowAdd(hContact, ICQEVENTTYPE_SMS, NULL, 0, (LPSTR)dbei.pBlob, dbei.cbBlob))
db_event_markRead(hContact, hDbEvent);
}
else {
memcpy(pszServiceFunctionName, SMS_READ, sizeof(SMS_READ));
mir_sntprintf(szToolTip, TranslateT("SMS Message from %s"), pcli->pfnGetContactDisplayName(hContact, 0));
CLISTEVENT cle = {};
cle.flags = CLEF_TCHAR;
cle.hContact = hContact;
cle.hDbEvent = hDbEvent;
cle.hIcon = Skin_LoadIcon(SKINICON_OTHER_SMS);
cle.pszService = szServiceFunction;
cle.ptszTooltip = szToolTip;
pcli->pfnAddEvent(&cle);
}
}
}
else if (dbei.eventType == ICQEVENTTYPE_SMSCONFIRMATION) {
SkinPlaySound("RecvSMSConfirmation");
if (DB_SMS_GetByte(NULL, "AutoPopup", 0)) {
if (RecvSMSWindowAdd(hContact, ICQEVENTTYPE_SMSCONFIRMATION, NULL, 0, (LPSTR)dbei.pBlob, dbei.cbBlob))
db_event_delete(hContact, hDbEvent);
}
else {
UINT iIcon;
if (GetDataFromMessage((LPSTR)dbei.pBlob, dbei.cbBlob, NULL, NULL, 0, NULL, &iIcon)) {
memcpy(pszServiceFunctionName, SMS_READ_ACK, sizeof(SMS_READ_ACK));
mir_sntprintf(szToolTip, TranslateT("SMS Confirmation from %s"), pcli->pfnGetContactDisplayName(hContact, 0));
CLISTEVENT cle = {};
cle.flags = CLEF_TCHAR;
cle.hContact = hContact;
cle.hDbEvent = hDbEvent;
cle.hIcon = (HICON)LoadImage(ssSMSSettings.hInstance, MAKEINTRESOURCE(iIcon), IMAGE_ICON, 0, 0, LR_SHARED);
cle.pszService = szServiceFunction;
cle.ptszTooltip = szToolTip;
pcli->pfnAddEvent(&cle);
}
}
}
MEMFREE(dbei.pBlob);
return 0;
}
// This function handles the ACK received from that hooked.
int handleAckSMS(WPARAM wParam, LPARAM lParam)
{
if (!lParam)
return 0;
if (((ACKDATA*)lParam)->type != ICQACKTYPE_SMS)
return 0;
char szPhone[MAX_PHONE_LEN] = { 0 };
TCHAR tszPhone[MAX_PHONE_LEN] = { 0 };
LPSTR lpszXML = (LPSTR)((ACKDATA*)lParam)->lParam, lpszData, lpszPhone;
size_t dwXMLSize = 0, dwDataSize, dwPhoneSize;
ACKDATA *ack = ((ACKDATA*)lParam);
if (lpszXML)
dwXMLSize = mir_strlen(lpszXML);
if (GetXMLFieldEx(lpszXML, dwXMLSize, &lpszData, &dwDataSize, "sms_message", "text", NULL)) {
if (GetXMLFieldEx(lpszXML, dwXMLSize, &lpszPhone, &dwPhoneSize, "sms_message", "sender", NULL)) {
LPSTR lpszMessageUTF;
size_t dwBuffLen, dwMessageXMLEncodedSize, dwMessageXMLDecodedSize;
DBEVENTINFO dbei = { sizeof(dbei) };
dwBuffLen = (dwDataSize + MAX_PATH);
dbei.pBlob = (LPBYTE)MEMALLOC((dwBuffLen + dwPhoneSize));
LPWSTR lpwszMessageXMLEncoded = (LPWSTR)MEMALLOC((dwBuffLen*sizeof(WCHAR)));
LPWSTR lpwszMessageXMLDecoded = (LPWSTR)MEMALLOC((dwBuffLen*sizeof(WCHAR)));
if (dbei.pBlob && lpwszMessageXMLEncoded && lpwszMessageXMLDecoded) {
dwMessageXMLEncodedSize = MultiByteToWideChar(CP_UTF8, 0, lpszData, (int)dwDataSize, lpwszMessageXMLEncoded, (int)dwBuffLen);
DecodeXML(lpwszMessageXMLEncoded, dwMessageXMLEncodedSize, lpwszMessageXMLDecoded, dwBuffLen, &dwMessageXMLDecodedSize);
lpszMessageUTF = (LPSTR)lpwszMessageXMLEncoded;
WideCharToMultiByte(CP_UTF8, 0, lpwszMessageXMLDecoded, (int)dwMessageXMLDecodedSize, lpszMessageUTF, (int)dwBuffLen, NULL, NULL);
dwPhoneSize = CopyNumberA(szPhone, lpszPhone, dwPhoneSize);
dwPhoneSize = MultiByteToWideChar(CP_UTF8, 0, szPhone, (int)dwPhoneSize, tszPhone, MAX_PHONE_LEN);
MCONTACT hContact = HContactFromPhone(tszPhone, dwPhoneSize);
dbei.szModule = GetModuleName(hContact);
dbei.timestamp = time(NULL);
dbei.flags = DBEF_UTF;
dbei.eventType = ICQEVENTTYPE_SMS;
dbei.cbBlob = (mir_snprintf((LPSTR)dbei.pBlob, ((dwBuffLen + dwPhoneSize)), "SMS From: +%s\r\n%s", szPhone, lpszMessageUTF) + sizeof(DWORD));
//dbei.pBlob=(LPBYTE)lpszBuff;
(*((DWORD*)(dbei.pBlob + (dbei.cbBlob - sizeof(DWORD))))) = 0;
MEVENT hResult = db_event_add(hContact, &dbei);
if (hContact == NULL) {
if (RecvSMSWindowAdd(NULL, ICQEVENTTYPE_SMS, tszPhone, dwPhoneSize, (LPSTR)dbei.pBlob, dbei.cbBlob)) {
db_event_markRead(hContact, hResult);
SkinPlaySound("RecvSMSMsg");
}
}
}
MEMFREE(lpwszMessageXMLDecoded);
MEMFREE(lpwszMessageXMLEncoded);
MEMFREE(dbei.pBlob);
}
}
else
if (GetXMLFieldEx(lpszXML, dwXMLSize, &lpszData, &dwDataSize, "sms_delivery_receipt", "delivered", NULL)) {
if (GetXMLFieldEx(lpszXML, dwXMLSize, &lpszPhone, &dwPhoneSize, "sms_delivery_receipt", "destination", NULL)) {
dwPhoneSize = CopyNumberA(szPhone, lpszPhone, dwPhoneSize);
dwPhoneSize = MultiByteToWideChar(CP_UTF8, 0, szPhone, (int)dwPhoneSize, tszPhone, MAX_PHONE_LEN);
MCONTACT hContact = HContactFromPhone(tszPhone, dwPhoneSize);
DBEVENTINFO dbei = { 0 };
dbei.cbSize = sizeof(dbei);
dbei.szModule = GetModuleName(hContact);
dbei.timestamp = time(NULL);
dbei.flags = DBEF_UTF;
dbei.eventType = ICQEVENTTYPE_SMSCONFIRMATION;
if (CompareStringA(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), NORM_IGNORECASE, lpszData, (int)dwDataSize, "yes", 3) == CSTR_EQUAL) {
dbei.cbBlob = (MAX_PHONE_LEN + MAX_PATH);
dbei.pBlob = (PBYTE)MEMALLOC(dbei.cbBlob);
if (dbei.pBlob) dbei.cbBlob = (mir_snprintf((LPSTR)dbei.pBlob, dbei.cbBlob, "SMS Confirmation From: +%s\r\nSMS was sent succesfully", szPhone) + 4);
}
else {
if (GetXMLFieldEx(lpszXML, dwXMLSize, &lpszData, &dwDataSize, "sms_delivery_receipt", "error", "params", "param", NULL) == FALSE) {
lpszData = "";
dwDataSize = 0;
}
dbei.cbBlob = (int)(MAX_PHONE_LEN + MAX_PATH + dwDataSize);
dbei.pBlob = (PBYTE)MEMALLOC(dbei.cbBlob);
if (dbei.pBlob) {
dbei.cbBlob = mir_snprintf((LPSTR)dbei.pBlob, dbei.cbBlob, "SMS Confirmation From: +%s\r\nSMS was not sent succesfully: ", szPhone);
memcpy((dbei.pBlob + dbei.cbBlob), lpszData, dwDataSize);
dbei.cbBlob += (int)(dwDataSize + sizeof(DWORD));
(*((DWORD*)(dbei.pBlob + (dbei.cbBlob - sizeof(DWORD))))) = 0;
}
}
if (dbei.pBlob) {
if (hContact)
db_event_add(hContact, &dbei);
else
RecvSMSWindowAdd(NULL, ICQEVENTTYPE_SMSCONFIRMATION, tszPhone, dwPhoneSize, (LPSTR)dbei.pBlob, dbei.cbBlob);
MEMFREE(dbei.pBlob);
}
}
}
else
if ((ack->result == ACKRESULT_FAILED) || GetXMLFieldEx(lpszXML, dwXMLSize, &lpszData, &dwDataSize, "sms_response", "deliverable", NULL)) {
HWND hWndDlg = SendSMSWindowHwndByHProcessGet(ack->hProcess);
if (hWndDlg) {
char szNetwork[MAX_PATH];
KillTimer(hWndDlg, wParam);
GetXMLFieldExBuff(lpszXML, dwXMLSize, szNetwork, sizeof(szNetwork), NULL, "sms_response", "network", NULL);
if (ack->result == ACKRESULT_FAILED || CompareStringA(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), NORM_IGNORECASE, lpszData, (int)dwDataSize, "no", 2) == CSTR_EQUAL) {
char szBuff[1024];
TCHAR tszErrorMessage[1028];
LPSTR lpszErrorDescription;
if (SendSMSWindowMultipleGet(hWndDlg)) {
TVITEM tvi;
tvi.mask = TVIF_TEXT;
tvi.hItem = SendSMSWindowHItemSendGet(hWndDlg);
tvi.pszText = tszPhone;
tvi.cchTextMax = _countof(tszPhone);
TreeView_GetItem(GetDlgItem(hWndDlg, IDC_NUMBERSLIST), &tvi);
}
else GetDlgItemText(hWndDlg, IDC_ADDRESS, tszPhone, _countof(szPhone));
if (ack->result == ACKRESULT_FAILED)
lpszErrorDescription = lpszXML;
else {
lpszErrorDescription = szBuff;
GetXMLFieldExBuff(lpszXML, dwXMLSize, szBuff, sizeof(szBuff), NULL, "sms_response", "error", "params", "param", NULL);
}
mir_sntprintf(tszErrorMessage, TranslateT("SMS message didn't send by %S to %s because: %S"), szNetwork, tszPhone, lpszErrorDescription);
ShowWindow(hWndDlg, SW_SHOWNORMAL);
EnableWindow(hWndDlg, FALSE);
HWND hwndTimeOut = CreateDialog(ssSMSSettings.hInstance, MAKEINTRESOURCE(IDD_SENDSMSTIMEDOUT), hWndDlg, SMSTimedOutDlgProc);
SetDlgItemText(hwndTimeOut, IDC_STATUS, tszErrorMessage);
}
else {
SendSMSWindowDBAdd(hWndDlg);
if (SendSMSWindowMultipleGet(hWndDlg)) {
if (SendSMSWindowNextHItemGet(hWndDlg, SendSMSWindowHItemSendGet(hWndDlg))) {
SendSMSWindowAsSentSet(hWndDlg);
SendSMSWindowHItemSendSet(hWndDlg, SendSMSWindowNextHItemGet(hWndDlg, SendSMSWindowHItemSendGet(hWndDlg)));
SendSMSWindowNext(hWndDlg);
}
else SendSMSWindowRemove(hWndDlg);
}
else {
if (CompareStringA(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), NORM_IGNORECASE, lpszData, (int)dwDataSize, "yes", 3) == CSTR_EQUAL ||
CompareStringA(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), NORM_IGNORECASE, lpszData, (int)dwDataSize, "smtp", 4) == CSTR_EQUAL) {
char szSource[MAX_PATH], szMessageID[MAX_PATH];
if (DB_SMS_GetByte(NULL, "ShowACK", SMS_DEFAULT_SHOWACK)) {
HWND hwndAccepted = CreateDialog(ssSMSSettings.hInstance, MAKEINTRESOURCE(IDD_SENDSMSACCEPT), hWndDlg, SMSAcceptedDlgProc);
if (CompareStringA(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), NORM_IGNORECASE, lpszData, (int)dwDataSize, "yes", 3) == CSTR_EQUAL) {
GetXMLFieldExBuff(lpszXML, dwXMLSize, szSource, sizeof(szSource), NULL, "sms_response", "source", NULL);
GetXMLFieldExBuff(lpszXML, dwXMLSize, szMessageID, sizeof(szMessageID), NULL, "sms_response", "message_id", NULL);
}
else {
SetDlgItemText(hwndAccepted, IDC_ST_SOURCE, TranslateT("From:"));
SetDlgItemText(hwndAccepted, IDC_ST_MESSAGEID, TranslateT("To:"));
GetXMLFieldExBuff(lpszXML, dwXMLSize, szSource, sizeof(szSource), NULL, "sms_response", "from", NULL);
GetXMLFieldExBuff(lpszXML, dwXMLSize, szMessageID, sizeof(szMessageID), NULL, "sms_response", "to", NULL);
}
SetDlgItemTextA(hwndAccepted, IDC_NETWORK, szNetwork);
SetDlgItemTextA(hwndAccepted, IDC_SOURCE, szSource);
SetDlgItemTextA(hwndAccepted, IDC_MESSAGEID, szMessageID);
}
else SendSMSWindowRemove(hWndDlg);
}
else SendSMSWindowRemove(hWndDlg);
}
}
}
}
return 0;
}
void* mem_pool::pool_alloc( size_t bytes )
{
void* ptr = NULL;
if( bytes > MEMORY_POOL_MAX )
{
ptr = MEMALLOC( bytes );
}
else
{
size_t index = LIST_INDEX( bytes );
if( pool_lock )
pool_lock( index );
if( pool[index].first && pool[index].useable > 0 )
{
int i;
mempage_t *prev = NULL, *curr = NULL;
/* 先查找页面缓存 */
for( i = 0; i < MEMORY_POOL_BUFFER; ++i )
{
if( pool[index].buffer[i] )
{
ptr = pool[index].buffer[i]->free;
pool[index].buffer[i]->free = pool[index].buffer[i]->free->next;
--( pool[index].buffer[i]->count );
/* 如果该页已无空闲块，则将该页自页面缓存中退出 */
if( pool[index].buffer[i]->count == 0 )
{
--( pool[index].useable );
pool[index].buffer[i] = NULL;
}
else
{
if( i > 0 )
{
/* 如果该页不在缓存首，则将该页调整至缓存首 */
pool[index].buffer[0] = pool[index].buffer[i];
pool[index].buffer[i] = NULL;
}
}
goto EXIT_POOL_ALLOC;
}
} /* end for */
/* 页面缓存为空，则遍历链中的所有内存页寻找空闲的内存块 */
curr = pool[index].first;
while( curr )
{
if( curr->count == 0 ) /* 该页中没有空闲块 */
{
/* 进入下一页 */
prev = curr;
curr = curr->next;
}
else /* 该页中有空闲块 */
{
size_t page_count = 0; /* 统计遍历过的可用内存页 */
ptr = curr->free;
curr->free = curr->free->next;
--( curr->count );
if( curr->count == 0 )
--( pool[index].useable );
/* 继续遍历链表，寻找其他还有空闲块的页面，将之放入页面缓存 */
while( curr && page_count < pool[index].useable )
{
if( curr->count != 0 )
{
/* 页面缓存还有位置则放入页面缓存 */
if( page_count < MEMORY_POOL_BUFFER )
pool[index].buffer[page_count] = curr;
++page_count;
/* 如果当前页未满并且不在链首，则将之移至链首 */
if( pool[index].first != curr )
{
prev->next = curr->next; /* 保存下一页 */
curr->next = pool[index].first;
pool[index].first = curr;
curr = prev->next; /* 进入下一页 */
continue;
}
}
/* 进入下一页 */
prev = curr;
curr = curr->next;
}
goto EXIT_POOL_ALLOC;
} /* end else */
} /* end while */
} /* end if pool[index].useable > 0 */
else
{
/* 该链下未分配内存页或无空闲块，此时需增加新的内存页 */
mempage_t* pg = NULL;
size_t blk_size = BLOCK_SIZE( index );
/* 如果 page_size = 0，则计算该内存链下每个内存页需占用的字节数 */
if( 0 == pool[index].page_size )
{
if( DEFAULT_PAGE_SIZE % blk_size == 0 )
pool[index].page_size = DEFAULT_PAGE_SIZE;
else
pool[index].page_size = (DEFAULT_PAGE_SIZE / blk_size)
* blk_size;
}
pg = (mempage_t*)MEMALLOC( sizeof(mempage_t)
+ pool[index].page_size );
if( pg )
{
memblk_t* curr = NULL;
size_t i, blk_count = BLOCK_COUNT( index );
pg->next = pool[index].first;
pool[index].first = pg;
/* 将内存页中的所有内存块串联成一个链表 */
curr = (memblk_t*)((unsigned char*)pg + sizeof(mempage_t));
pg->free = curr;
for( i = 1; i < blk_count; ++i )
{
curr->next = (memblk_t*)((unsigned char*)curr + blk_size);
curr = curr->next;
}
curr->next = NULL;
ptr = pg->free;
pg->free = pg->free->next;
pg->count = blk_count - 1;
++( pool[index].useable );
pool[index].buffer[0] = pg;
}
}
EXIT_POOL_ALLOC:
if( pool_unlock )
pool_unlock( index );
} /* end else */
if( ptr )
++pool_alloc_count;
return ptr;
}
