bool ConfFile::SetPrivate(const char* pcSpace, const char* pcKey, const char* pcValue)
{
string strSpace = pcSpace;
string strKey = pcKey;
string strValue = pcValue;
return SetPrivate(strSpace, strKey, strValue);
}
result_t TcpServer::set_handler(Handler_base* newVal)
{
SetPrivate("handler", newVal->wrap());
m_hdlr = newVal;
return 0;
}
result_t LruCache::get(exlib::string name, v8::Local<v8::Function> updater,
v8::Local<v8::Value> &retVal)
{
static _linkedNode newNode;
v8::Handle<v8::Object> o = wrap();
Isolate* isolate = holder();
exlib::string sname(name);
v8::Handle<v8::Value> a = isolate->NewFromUtf8(name);
std::map<exlib::string, _linkedNode>::iterator find;
cleanup();
while (true)
{
obj_ptr<Event_base> e;
find = m_datas.find(sname);
if (find != m_datas.end())
break;
if (updater.IsEmpty())
return 0;
std::map<exlib::string, obj_ptr<Event_base> >::iterator padding;
padding = m_paddings.find(sname);
if (padding == m_paddings.end())
{
e = new Event();
padding = m_paddings.insert(std::pair<exlib::string, obj_ptr<Event_base> >(sname, e)).first;
v8::Local<v8::Value> v = updater->Call(o, 1, &a);
m_paddings.erase(padding);
e->set();
if (v.IsEmpty())
return CALL_E_JAVASCRIPT;
find = m_datas.insert(std::pair<exlib::string, _linkedNode>(sname, newNode)).first;
insert(find);
if (m_timeout > 0)
find->second.insert.now();
SetPrivate(name, v);
retVal = v;
return 0;
}
e = padding->second;
e->wait();
}
update(find);
retVal = GetPrivate(name);
return 0;
}
result_t WebSocketHandler::set_handler(Handler_base *newVal)
{
obj_ptr<Handler_base> hdlr = (Handler_base*)m_hdlr;
SetPrivate("handler", newVal->wrap());
m_hdlr = newVal;
if (hdlr)
hdlr->dispose();
return 0;
}
result_t SslServer::create(v8::Local<v8::Array> certs, exlib::string addr, int32_t port,
v8::Local<v8::Value> listener)
{
result_t hr;
obj_ptr<TcpServer_base> _server;
obj_ptr<SslHandler_base> _handler;
hr = SslHandler_base::_new(certs, listener, _handler);
if (hr < 0)
return hr;
hr = TcpServer_base::_new(addr, port, _handler->wrap(), _server);
if (hr < 0)
return hr;
m_server = _server;
SetPrivate("handler", _handler->wrap());
SetPrivate("server", _server->wrap());
return 0;
}
result_t LruCache::set(exlib::string name, v8::Local<v8::Value> value)
{
std::map<exlib::string, _linkedNode>::iterator find = m_datas.find(name);
if (find != m_datas.end())
{
update(find);
update_time(find);
if (m_timeout > 0)
find->second.insert.now();
SetPrivate(name, value);
}
cleanup();
return 0;
}
result_t WebSocketHandler::onerror(v8::Local<v8::Object> hdlrs)
{
Isolate* isolate = holder();
v8::Local<v8::String> key = isolate->NewFromUtf8("500");
v8::Local<v8::Value> hdlr = hdlrs->Get(key);
if (!IsEmpty(hdlr))
{
obj_ptr<Handler_base> hdlr1;
result_t hr = JSHandler::New(hdlr, hdlr1);
if (hr < 0)
return hr;
SetPrivate("500", hdlr1->wrap());
m_err_hdlr = hdlr1;
}
return 0;
}
result_t LruCache::put(exlib::string name, v8::Local<v8::Value> value)
{
static _linkedNode newNode;
std::map<exlib::string, _linkedNode>::iterator find = m_datas.find(name);
if (find == m_datas.end())
{
find = m_datas.insert(std::pair<exlib::string, _linkedNode>(name, newNode)).first;
insert(find);
}
else
{
update(find);
update_time(find);
}
if (m_timeout > 0)
find->second.insert.now();
SetPrivate(name, value);
cleanup();
return 0;
}
HRESULT MAPITask::SetMAPITaskValues()
{
SizedSPropTagArray(T_NUMALLTASKPROPS, taskProps) = {
T_NUMALLTASKPROPS, {
PR_MESSAGE_FLAGS, PR_SUBJECT, PR_BODY, PR_HTML, PR_IMPORTANCE, pr_isrecurringt, pr_recurstreamt, pr_status,
pr_percentcomplete, pr_taskstart, pr_taskdue, pr_totalwork,
pr_actualwork, pr_companies, pr_mileage, pr_billinginfo,
pr_taskreminderset, pr_taskflagdueby, pr_private
}
};
HRESULT hr = S_OK;
ULONG cVals = 0;
m_bHasAttachments = false;
m_bIsRecurring = false;
m_bIsTaskReminderSet = false;
if (FAILED(hr = m_pMessage->GetProps((LPSPropTagArray) & taskProps, fMapiUnicode, &cVals,
&m_pPropVals)))
throw MAPITaskException(hr, L"SetMAPITaskValues(): GetProps Failed.",
ERR_MAPI_TASK, __LINE__, __FILE__);
if (m_pPropVals[T_MESSAGE_FLAGS].ulPropTag == taskProps.aulPropTag[T_MESSAGE_FLAGS])
{
m_bHasAttachments = (m_pPropVals[T_MESSAGE_FLAGS].Value.l & MSGFLAG_HASATTACH) != 0;
}
if (m_pPropVals[T_ISRECURT].ulPropTag == taskProps.aulPropTag[T_ISRECURT]) // do this first to set dates correctly
{
m_bIsRecurring = (m_pPropVals[T_ISRECURT].Value.b == 1);
}
if (m_pPropVals[T_TASKREMINDERSET].ulPropTag == taskProps.aulPropTag[T_TASKREMINDERSET]) // do this first to set dates correctly
{
m_bIsTaskReminderSet = (m_pPropVals[T_TASKREMINDERSET].Value.b == 1);
}
if (m_pPropVals[T_SUBJECT].ulPropTag == taskProps.aulPropTag[T_SUBJECT])
{
SetSubject(m_pPropVals[T_SUBJECT].Value.lpszW);
}
if (m_pPropVals[T_IMPORTANCE].ulPropTag == taskProps.aulPropTag[T_IMPORTANCE])
{
SetImportance(m_pPropVals[T_IMPORTANCE].Value.l);
}
if (m_pPropVals[T_STATUS].ulPropTag == taskProps.aulPropTag[T_STATUS])
{
SetTaskStatus(m_pPropVals[T_STATUS].Value.l);
}
if (m_pPropVals[T_PERCENTCOMPLETE].ulPropTag == taskProps.aulPropTag[T_PERCENTCOMPLETE])
{
SetPercentComplete(m_pPropVals[T_PERCENTCOMPLETE].Value.dbl);
}
if (m_pPropVals[T_TASKSTART].ulPropTag == taskProps.aulPropTag[T_TASKSTART])
{
SetTaskStart(m_pPropVals[T_TASKSTART].Value.ft);
}
if (m_pPropVals[T_TASKDUE].ulPropTag == taskProps.aulPropTag[T_TASKDUE])
{
SetTaskDue(m_pPropVals[T_TASKDUE].Value.ft);
}
if (m_pPropVals[T_TOTALWORK].ulPropTag == taskProps.aulPropTag[T_TOTALWORK])
{
SetTotalWork(m_pPropVals[T_TOTALWORK].Value.l);
}
if (m_pPropVals[T_ACTUALWORK].ulPropTag == taskProps.aulPropTag[T_ACTUALWORK])
{
SetActualWork(m_pPropVals[T_ACTUALWORK].Value.l);
}
if (m_pPropVals[T_COMPANIES].ulPropTag == taskProps.aulPropTag[T_COMPANIES])
{
SetCompanies(m_pPropVals[T_COMPANIES].Value.MVszW.lppszW[0]); // get first one for now
}
if (m_pPropVals[T_MILEAGE].ulPropTag == taskProps.aulPropTag[T_MILEAGE])
{
SetMileage(m_pPropVals[T_MILEAGE].Value.lpszW);
}
if (m_pPropVals[T_BILLING].ulPropTag == taskProps.aulPropTag[T_BILLING])
{
SetBillingInfo(m_pPropVals[T_BILLING].Value.lpszW);
}
if (m_pPropVals[T_TASKFLAGDUEBY].ulPropTag == taskProps.aulPropTag[T_TASKFLAGDUEBY])
{
SetTaskFlagDueBy(m_pPropVals[T_TASKFLAGDUEBY].Value.ft);
}
if (m_pPropVals[T_PRIVATE].ulPropTag == taskProps.aulPropTag[T_PRIVATE])
{
SetPrivate(m_pPropVals[T_PRIVATE].Value.b);
}
SetPlainTextFileAndContent();
SetHtmlFileAndContent();
if (m_bHasAttachments)
{
if (FAILED(ExtractAttachments()))
{
dlogw(L"Could not extract attachments");
}
}
if (m_bIsRecurring)
{
if (m_pPropVals[T_RECURSTREAMT].ulPropTag == taskProps.aulPropTag[T_RECURSTREAMT])
{
SetRecurValues();
}
}
return hr;
}
JSTimer(v8::Local<v8::Function> callback, int32_t timeout = 0, bool repeat = false) :
Timer(timeout, repeat)
{
SetPrivate("callback", callback);
}
HRESULT MAPIAppointment::SetMAPIAppointmentValues()
{
SizedSPropTagArray(C_NUMALLAPPTPROPS, appointmentProps) = {
C_NUMALLAPPTPROPS, {
PR_MESSAGE_FLAGS, PR_SUBJECT, PR_BODY, PR_HTML, pr_clean_global_objid,
pr_appt_start, pr_appt_end, pr_location, pr_busystatus, pr_allday,
pr_isrecurring, pr_recurstream, pr_timezoneid, pr_responsestatus,
PR_RESPONSE_REQUESTED,pr_exceptionreplacetime,
pr_reminderminutes, pr_private, pr_reminderset
}
};
HRESULT hr = S_OK;
ULONG cVals = 0;
bool bAllday = false;
m_bHasAttachments = false;
m_bIsRecurring = false;
// get the zimbra appt wrapper around the mapi message
Zimbra::Mapi::Appt appt(m_pMessage, m_mapiStore->GetInternalMAPIStore());
// save off the default timezone info for this appointment
try
{
hr = appt.GetTimezone(_olkTz, &_pTzString);
}
catch(...)
{
hr=E_FAIL;
}
if (SUCCEEDED(hr))
{
// get the timezone info for this appt
pInvTz= new Zimbra::Mail::TimeZone(_pTzString);
pInvTz->Initialize(_olkTz, _pTzString);
}
if (FAILED(hr = m_pMessage->GetProps((LPSPropTagArray) & appointmentProps, fMapiUnicode, &cVals,
&m_pPropVals)))
throw MAPIAppointmentException(hr, L"SetMAPIAppointmentValues(): GetProps Failed.",
ERR_MAPI_APPOINTMENT, __LINE__, __FILE__);
if (m_pPropVals[C_MESSAGE_FLAGS].ulPropTag == appointmentProps.aulPropTag[C_MESSAGE_FLAGS])
{
m_bHasAttachments = (m_pPropVals[C_MESSAGE_FLAGS].Value.l & MSGFLAG_HASATTACH) != 0;
}
if (m_pPropVals[C_ISRECUR].ulPropTag == appointmentProps.aulPropTag[C_ISRECUR]) // do this first to set dates correctly
{
m_bIsRecurring = (m_pPropVals[C_ISRECUR].Value.b == 1);
}
if (m_pPropVals[C_ALLDAY].ulPropTag == appointmentProps.aulPropTag[C_ALLDAY])
{
SetAllday(m_pPropVals[C_ALLDAY].Value.b);
bAllday = (m_pPropVals[C_ALLDAY].Value.b == 1);
}
if (m_pPropVals[C_SUBJECT].ulPropTag == appointmentProps.aulPropTag[C_SUBJECT])
{
SetSubject(m_pPropVals[C_SUBJECT].Value.lpszW);
}
if (m_pPropVals[C_UID].ulPropTag == appointmentProps.aulPropTag[C_UID])
{
SetInstanceUID(&m_pPropVals[C_UID].Value.bin);
}
if (m_pPropVals[C_START].ulPropTag == appointmentProps.aulPropTag[C_START])
{
SetStartDate(m_pPropVals[C_START].Value.ft);
}
if (m_pPropVals[C_END].ulPropTag == appointmentProps.aulPropTag[C_END])
{
SetEndDate(m_pPropVals[C_END].Value.ft, bAllday);
}
if (m_pPropVals[C_LOCATION].ulPropTag == appointmentProps.aulPropTag[C_LOCATION])
{
SetLocation(m_pPropVals[C_LOCATION].Value.lpszW);
}
if (m_pPropVals[C_BUSYSTATUS].ulPropTag == appointmentProps.aulPropTag[C_BUSYSTATUS])
{
SetBusyStatus(m_pPropVals[C_BUSYSTATUS].Value.l);
}
if (m_pPropVals[C_RESPONSESTATUS].ulPropTag == appointmentProps.aulPropTag[C_RESPONSESTATUS])
{
SetResponseStatus(m_pPropVals[C_RESPONSESTATUS].Value.l);
}
if (m_pPropVals[C_RESPONSEREQUESTED].ulPropTag == appointmentProps.aulPropTag[C_RESPONSEREQUESTED])
{
SetResponseRequested(m_pPropVals[C_RESPONSEREQUESTED].Value.b);
}
unsigned short usReminderSet=1;
if (m_pPropVals[C_REMINDERSET].ulPropTag == appointmentProps.aulPropTag[C_REMINDERSET])
{
usReminderSet= m_pPropVals[C_REMINDERSET].Value.b;
}
if(usReminderSet)
{
if (m_pPropVals[C_REMINDERMINUTES].ulPropTag == appointmentProps.aulPropTag[C_REMINDERMINUTES])
{
SetReminderMinutes(m_pPropVals[C_REMINDERMINUTES].Value.l);
}
}
if (m_pPropVals[C_PRIVATE].ulPropTag == appointmentProps.aulPropTag[C_PRIVATE])
{
SetPrivate(m_pPropVals[C_PRIVATE].Value.b);
}
SetTransparency(L"O");
SetPlainTextFileAndContent();
SetHtmlFileAndContent();
if (m_bHasAttachments)
{
if (FAILED(ExtractAttachments()))
{
dlogw(L"Could not extract attachments");
}
}
hr = SetOrganizerAndAttendees();
if(FAILED(hr))
{
dlogw(L"SetOrganizerAndAttendees failed");
}
if ((m_bIsRecurring) && (m_iExceptionType != CANCEL_EXCEPTION))
{
if (m_pPropVals[C_RECURSTREAM].ulPropTag == appointmentProps.aulPropTag[C_RECURSTREAM])
{
// special case for timezone id
if (m_pPropVals[C_TIMEZONEID].ulPropTag == appointmentProps.aulPropTag[C_TIMEZONEID])
{
SetTimezoneId(m_pPropVals[C_TIMEZONEID].Value.lpszW);
}
//
int numExceptions = SetRecurValues(); // returns null if no exceptions
if (numExceptions > 0)
{
SetExceptions();
}
}
}
return hr;
}
int handlemodemsg(void *source, int cargc, char **cargv) {
channel *cp;
int dir=1;
int arg=2;
char *modestr;
unsigned long *lp;
void *harg[4];
nick *np, *target;
int hooknum;
int changes=0;
if (cargc<2) {
return CMD_OK;
}
if (cargv[0][0]!='#' && cargv[0][0]!='+') {
/* Not a channel, ignore */
return CMD_OK;
}
if ((cp=findchannel(cargv[0]))==NULL) {
/* No channel, abort */
Error("channel",ERR_WARNING,"Mode change on non-existent channel %s",cargv[0]);
return CMD_OK;
}
if (((char *)source)[2]=='\0') {
/* Server mode change, treat as divine intervention */
np=NULL;
} else if ((np=getnickbynumericstr((char *)source))==NULL) {
/* No sender, continue but moan */
Error("channel",ERR_WARNING,"Mode change by non-existent user %s on channel %s",(char *)source,cp->index->name->content);
}
/* Set up the hook data */
harg[0]=cp;
harg[1]=np;
harg[3]=(void *)(long)(cp->flags);
/* Process the mode string one character at a time */
/* Maybe I'll write this more intelligently one day if I can comprehend the ircu code that does this */
for (modestr=cargv[1];*modestr;modestr++) {
switch(*modestr) {
/* Set whether we are adding or removing modes */
case '+':
dir=1;
break;
case '-':
dir=0;
break;
/* Simple modes: just set or clear based on value of dir */
case 'n':
if (dir) { SetNoExtMsg(cp); } else { ClearNoExtMsg(cp); }
changes |= MODECHANGE_MODES;
break;
case 't':
if (dir) { SetTopicLimit(cp); } else { ClearTopicLimit(cp); }
changes |= MODECHANGE_MODES;
break;
case 's':
if (dir) { SetSecret(cp); ClearPrivate(cp); } else { ClearSecret(cp); }
changes |= MODECHANGE_MODES;
break;
case 'p':
if (dir) { SetPrivate(cp); ClearSecret(cp); } else { ClearPrivate(cp); }
changes |= MODECHANGE_MODES;
break;
case 'i':
if (dir) { SetInviteOnly(cp); } else { ClearInviteOnly(cp); }
changes |= MODECHANGE_MODES;
break;
case 'm':
if (dir) { SetModerated(cp); } else { ClearModerated(cp); }
changes |= MODECHANGE_MODES;
break;
case 'c':
if (dir) { SetNoColour(cp); } else { ClearNoColour(cp); }
changes |= MODECHANGE_MODES;
break;
case 'C':
if (dir) { SetNoCTCP(cp); } else { ClearNoCTCP(cp); }
changes |= MODECHANGE_MODES;
break;
case 'r':
if (dir) { SetRegOnly(cp); } else { ClearRegOnly(cp); }
changes |= MODECHANGE_MODES;
break;
case 'D':
if (dir) { SetDelJoins(cp); } else { ClearDelJoins(cp); }
changes |= MODECHANGE_MODES;
break;
case 'u':
if (dir) { SetNoQuitMsg(cp); } else { ClearNoQuitMsg(cp); }
changes |= MODECHANGE_MODES;
break;
case 'N':
if (dir) { SetNoNotice(cp); } else { ClearNoNotice(cp); }
changes |= MODECHANGE_MODES;
break;
case 'M':
if (dir) { SetModNoAuth(cp); } else { ClearModNoAuth(cp); }
changes |= MODECHANGE_MODES;
break;
case 'T':
if (dir) { SetSingleTarg(cp); } else { ClearSingleTarg(cp); }
changes |= MODECHANGE_MODES;
break;
/* Parameter modes: advance parameter and possibly read it in */
case 'l':
if (dir) {
/* +l uses a parameter, but -l does not.
* If there is no parameter, don't set the mode.
* I guess we should moan too in that case, but
* they might be even nastier to us if we do ;) */
if (arg<cargc) {
cp->limit=strtol(cargv[arg++],NULL,10);
SetLimit(cp);
}
} else {
ClearLimit(cp);
cp->limit=0;
}
changes |= MODECHANGE_MODES;
break;
case 'k':
if (dir) {
/* +k uses a parameter in both directions */
if (arg<cargc) {
freesstring(cp->key); /* It's probably NULL, but be safe */
cp->key=getsstring(cargv[arg++],KEYLEN);
SetKey(cp);
}
} else {
freesstring(cp->key);
cp->key=NULL;
ClearKey(cp);
arg++; /* Eat the arg without looking at it, even if it's not there */
}
changes |= MODECHANGE_MODES;
break;
/* Op/Voice */
case 'o':
case 'v':
if (arg<cargc) {
if((lp=getnumerichandlefromchanhash(cp->users,numerictolong(cargv[arg++],5)))==NULL) {
/* They're not on the channel; MODE crossed with part/kill/kick/blah */
Error("channel",ERR_DEBUG,"Mode change for user %s not on channel %s",cargv[arg-1],cp->index->name->content);
} else {
if ((target=getnickbynumeric(*lp))==NULL) {
/* This really is a fuckup, we found them on the channel but there isn't a user with that numeric */
/* This means there's a serious bug in the nick/channel tracking code */
Error("channel",ERR_ERROR,"Mode change for user %s on channel %s who doesn't exist",cargv[arg-1],cp->index->name->content);
} else { /* Do the mode change whilst admiring the beautiful code layout */
harg[2]=target;
if (*modestr=='o') { if (dir) { *lp |= CUMODE_OP; hooknum=HOOK_CHANNEL_OPPED; } else
{ *lp &= ~CUMODE_OP; hooknum=HOOK_CHANNEL_DEOPPED; } }
else { if (dir) { *lp |= CUMODE_VOICE; hooknum=HOOK_CHANNEL_VOICED; } else
{ *lp &= ~CUMODE_VOICE; hooknum=HOOK_CHANNEL_DEVOICED; } }
triggerhook(hooknum,harg);
}
}
}
changes |= MODECHANGE_USERS;
break;
case 'b':
if (arg<cargc) {
if (dir) {
setban(cp,cargv[arg++]);
triggerhook(HOOK_CHANNEL_BANSET,harg);
} else {
clearban(cp,cargv[arg++],0);
triggerhook(HOOK_CHANNEL_BANCLEAR,harg);
}
}
changes |= MODECHANGE_BANS;
break;
default:
Error("channel",ERR_DEBUG,"Unknown mode char '%c' %s on %s",*modestr,dir?"set":"cleared",cp->index->name->content);
break;
}
}
harg[2]=(void *)((long)changes);
triggerhook(HOOK_CHANNEL_MODECHANGE,(void *)harg);
return CMD_OK;
}
