const char *
mfn_with(MFUNARGS)
{
char vbuf[BUFFER_LEN];
char *ptr, *valptr;
int v, cnt;
ptr = MesgParse(argv[0], argv[0]);
CHECKRETURN(ptr,"WITH","arg 1");
v = new_mvar(ptr, vbuf);
if (v == 1)
ABORT_MPI("WITH","Variable name too long");
if (v == 2)
ABORT_MPI("WITH","Too many variables already defined");
valptr = MesgParse(argv[1], argv[1]);
CHECKRETURN(valptr,"WITH","arg 2");
*buf = '\0';
strcpy(vbuf, valptr);
for (cnt = 2; cnt < argc; cnt++) {
ptr = MesgParse(argv[cnt],argv[cnt]);
if (!ptr) {
sprintf(buf, "%s %cWITH%c (%d)", get_mvar("how"),
MFUN_LEADCHAR, MFUN_ARGEND, cnt);
notify(player, buf);
return NULL;
}
}
free_top_mvar();
return ptr;
}
const char *
mfn_func(MFUNARGS)
{
char *funcname;
char *ptr=NULL, *def;
char namebuf[BUFFER_LEN];
char argbuf[BUFFER_LEN];
char defbuf[BUFFER_LEN];
int i;
funcname = MesgParse(argv[0], namebuf, sizeof(namebuf));
CHECKRETURN(funcname, "FUNC", "name argument (1)");
def = argv[argc - 1];
for (i = 1; i < argc - 1; i++) {
ptr = MesgParse(argv[i], argbuf, sizeof(argbuf));
CHECKRETURN(ptr, "FUNC", "variable name argument");
snprintf(defbuf, sizeof(defbuf), "{with:%.*s,{:%d},%.*s}", MAX_MFUN_NAME_LEN, ptr, i,
(BUFFER_LEN - MAX_MFUN_NAME_LEN - 20), def);
}
i = new_mfunc(funcname, defbuf);
if (i == 1)
ABORT_MPI("FUNC", "Function Name too long.");
if (i == 2)
ABORT_MPI("FUNC", "Too many functions defined.");
return "";
}
const char *
mfn_commas(MFUNARGS)
{
int v, i, count;
char *ptr;
char buf2[BUFFER_LEN];
char tmp[BUFFER_LEN];
if (argc == 3)
ABORT_MPI("COMMAS","Takes 1, 2, or 4 arguments");
ptr = MesgParse(argv[0], argv[0]);
CHECKRETURN(ptr,"COMMAS","arg 1");
count = countlitems(argv[0], "\r");
if (count == 0) return "";
if (argc > 1) {
ptr = MesgParse(argv[1], argv[1]);
CHECKRETURN(ptr,"COMMAS","arg 2");
} else {
strcpy(argv[1], " and ");
}
if (argc > 2) {
ptr = MesgParse(argv[2], buf2);
CHECKRETURN(ptr,"COMMAS","arg 3");
v = new_mvar(ptr, tmp);
if (v == 1)
ABORT_MPI("COMMAS","Variable name too long");
if (v == 2)
ABORT_MPI("COMMAS","Too many variables already defined");
}
*buf = '\0';
for (i = 1; i <= count; i++) {
ptr = getlitem(buf2, argv[0], "\r", i);
if (argc > 2) {
strcpy(tmp, ptr);
ptr = MesgParse(argv[3], buf2);
CHECKRETURN(ptr,"COMMAS","arg 3");
}
strcat(buf, ptr);
switch (count - i) {
case 0:
if (argc > 2) free_top_mvar();
return buf;
break;
case 1:
strcat(buf, argv[1]);
break;
default:
strcat(buf, ", ");
break;
}
}
if (argc > 2) free_top_mvar();
return buf;
}
const char *
mfn_filter(MFUNARGS)
{
int iter_limit = MAX_MFUN_LIST_LEN;
char buf2[BUFFER_LEN];
char tmp[BUFFER_LEN];
char *ptr, *ptr2, *dptr;
char *sepin = argv[3];
char *sepbuf = argv[4];
int seplen, v;
ptr = MesgParse(argv[0],argv[0]);
CHECKRETURN(ptr,"FILTER","arg 1");
v = new_mvar(ptr, tmp);
if (v == 1)
ABORT_MPI("FILTER","Variable name too long.");
if (v == 2)
ABORT_MPI("FILTER","Too many variables already defined.");
dptr = MesgParse(argv[1],argv[1]);
CHECKRETURN(dptr,"FILTER","arg 2");
if (argc > 3) {
ptr = MesgParse(sepin,sepin);
CHECKRETURN(ptr,"FILTER","arg 4");
if (!*ptr)
ABORT_MPI("FILTER","Can't use Null seperator string");
} else {
strcpy(sepin, "\r");
}
if (argc > 4) {
ptr = MesgParse(sepbuf,sepbuf);
CHECKRETURN(ptr,"FILTER","arg 5");
} else {
strcpy(sepbuf, sepin);
}
seplen = strlen(sepin);
*buf = '\0';
ptr = dptr;
while (*ptr) {
for (ptr2 = ptr; *ptr2 && strncmp(ptr2, sepin, seplen); ptr2++);
if (*ptr2) {
*ptr2 = '\0';
ptr2 += seplen;
}
strcpy(tmp, ptr);
dptr = MesgParse(argv[2],buf2);
CHECKRETURN(dptr,"FILTER","arg 3");
if (truestr(buf2)) {
if (*buf) strcat(buf, sepbuf);
strcat(buf, ptr);
}
ptr = ptr2;
if (!(--iter_limit))
ABORT_MPI("FILTER","Iteration limit exceeded");
}
free_top_mvar();
return buf;
}
const char *
mfn_debugif(MFUNARGS)
{
char *ptr = MesgParse(argv[0], argv[0]);
CHECKRETURN(ptr,"DEBUGIF","arg 1");
if (truestr(argv[0])) {
ptr = mesg_parse(player, what, perms, argv[1],
buf, BUFFER_LEN, (mesgtyp | MPI_ISDEBUG));
} else {
ptr = MesgParse(argv[1], buf);
}
CHECKRETURN(ptr,"DEBUGIF","arg 2");
return buf;
}
const char *
mfn_rand(MFUNARGS)
{
int num = 0;
dbref trg = (dbref) 0, obj = what;
const char *pname, *ptr;
int blessed = 0;
pname = argv[0];
if (argc == 2) {
obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
}
if (obj == PERMDENIED)
ABORT_MPI("RAND", "Permission denied.");
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("RAND", "Match failed.");
num = get_list_count(what, obj, perms, (char *)pname, mesgtyp, &blessed);
if (!num)
ABORT_MPI("RAND", "Failed list read.");
ptr = get_list_item(what, obj, perms, (char *)pname, (((RANDOM() / 256) % num) + 1), mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("RAND", "Failed list read.");
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(ptr) || Prop_Private(ptr) || Prop_SeeOnly(ptr) || Prop_Hidden(ptr))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "RAND", "listval");
return ptr;
}
const char *
mfn_evalbang(MFUNARGS)
{
int i, len, len2;
char buf2[BUFFER_LEN];
char* ptr;
strcpyn(buf, buflen, argv[0]);
len = strlen(buf);
for (i = 1; i < argc; i++) {
len2 = strlen(argv[i]);
if (len2 + len + 3 >= BUFFER_LEN) {
if (len + 3 < BUFFER_LEN) {
strncpy(buf + len, argv[i], (BUFFER_LEN - len - 3));
buf[BUFFER_LEN - 3] = '\0';
}
break;
}
strcpyn(buf + len, buflen - len, ",");
strcpyn(buf + len, buflen - len, argv[i]);
len += len2;
}
strcpyn(buf2, sizeof(buf2), buf);
ptr = mesg_parse(descr, player, what, perms, buf2, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "EVAL!", "arg 1");
return buf;
}
const char *
mfn_lexec(MFUNARGS)
{
dbref trg = (dbref) 0, obj = what;
char *pname;
const char *ptr;
int blessed = 0;
pname = argv[0];
if (argc == 2) {
obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
}
if (obj == PERMDENIED)
ABORT_MPI("LEXEC", "Permission denied.");
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("LEXEC", "Match failed.");
while (*pname == PROPDIR_DELIMITER)
pname++;
ptr = get_concat_list(player, what, perms, obj, (char *)pname, buf, BUFFER_LEN, 2, mesgtyp, &blessed);
if (!ptr)
ptr = "";
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(pname) || Prop_Private(pname) || Prop_SeeOnly(pname) || Prop_Hidden(pname))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "LEXEC", "listval");
return ptr;
}
const char *
mfn_default(MFUNARGS)
{
char *ptr;
*buf = '\0';
ptr = MesgParse(argv[0], buf, buflen);
CHECKRETURN(ptr, "DEFAULT", "arg 1");
if (ptr && truestr(buf)) {
if (!ptr)
ptr = "";
} else {
ptr = MesgParse(argv[1], buf, buflen);
CHECKRETURN(ptr, "DEFAULT", "arg 2");
}
return ptr;
}
int DeviceIOClient::GetVideoOutputs(DevIOGetVideoOutputsResponse & resp)
{
DevIOGetVideoOutputs req(m_proxy.soap);
int nRes = m_proxy.GetVideoOutputs(req.d, resp.d);
CHECKRETURN(nRes, "DeviceIOClient::GetVideoOutputs");
}
int DeviceServiceImpl::GetSystemDateAndTime(_tds__GetSystemDateAndTime *tds__GetSystemDateAndTime, _tds__GetSystemDateAndTimeResponse *tds__GetSystemDateAndTimeResponse)
{
DevGetSystemDateAndTimeResponse dt(tds__GetSystemDateAndTimeResponse);
int nRes = m_pBaseServer->GetDateAndTime(dt);
CHECKRETURN(nRes, "DeviceServiceImpl::GetSystemDateAndTime");
};
int DeviceServiceImpl::GetUsers(_tds__GetUsers *tds__GetUsers, _tds__GetUsersResponse *tds__GetUsersResponse)
{
DevGetUsersResponse resp(tds__GetUsersResponse);
int nRes = m_pBaseServer->GetUsers(resp);
CHECKRETURN(nRes, "DeviceServiceImpl::GetUsers");
}
const char *
mfn_debug(MFUNARGS)
{
char *ptr = mesg_parse(player, what, perms, argv[0],
buf, BUFFER_LEN, (mesgtyp | MPI_ISDEBUG));
CHECKRETURN(ptr,"DEBUG","arg 1");
return buf;
}
int ReceiverClient::GetReceivers(RecvGetReceiversResponse & resp)
{
RecvGetReceivers req(m_proxy.soap);
int nRes = m_proxy.GetReceivers(req.d, resp.d);
CHECKRETURN(nRes, "ReceiverClient::GetReceivers");
}
int DisplayServiceImpl::SetLayout(_tls__SetLayout *tls__SetLayout, _tls__SetLayoutResponse *tls__SetLayoutResponse)
{
DispSetLayout req(tls__SetLayout);
int iRet = m_pBaseServer->SetLayout(req);
CHECKRETURN(iRet, "DisplayServiceImpl::SetLayout");
}
int DisplayServiceImpl::CreatePaneConfiguration(_tls__CreatePaneConfiguration *tls__CreatePaneConfiguration, _tls__CreatePaneConfigurationResponse *tls__CreatePaneConfigurationResponse)
{
DispCreatePaneConfiguration req(tls__CreatePaneConfiguration);
DispCreatePaneConfigurationResponse resp(tls__CreatePaneConfigurationResponse);
int iRet = m_pBaseServer->CreatePaneConfiguration(req, resp);
// FIXME NO RESP SETTING
CHECKRETURN(iRet, "DisplayServiceImpl::CreatePaneConfiguration");
}
const char *
mfn_while(MFUNARGS)
{
int iter_limit = MAX_MFUN_LIST_LEN;
char buf2[BUFFER_LEN];
char *ptr;
*buf = '\0';
while (1) {
ptr = MesgParse(argv[0], buf2, sizeof(buf2));
CHECKRETURN(ptr, "WHILE", "arg 1");
if (!truestr(ptr))
break;
ptr = MesgParse(argv[1], buf, buflen);
CHECKRETURN(ptr, "WHILE", "arg 2");
if (!(--iter_limit))
ABORT_MPI("WHILE", "Iteration limit exceeded");
}
return buf;
}
int DisplayServiceImpl::GetDisplayOptions(_tls__GetDisplayOptions *tls__GetDisplayOptions, _tls__GetDisplayOptionsResponse *tls__GetDisplayOptionsResponse)
{
DispGetDisplayOptions req(tls__GetDisplayOptions);
DispGetDisplayOptionsResponse resp(tls__GetDisplayOptionsResponse);
std::string VOToken;
req.GetVO(VOToken);
int iRet = m_pBaseServer->GetDisplayOptions(VOToken, resp);
CHECKRETURN(iRet, "DisplayServiceImpl::GetDisplayOptions");
}
int ReceiverClient::CreateReceiver(const std::string &uri, std::string & recvToken)
{
RecvCreateReceiver req(m_proxy.soap);
RecvCreateReceiverResponse resp(m_proxy.soap);
req.setUri(uri);
req.setMode(0);
int nRes = m_proxy.CreateReceiver(req.d, resp.d);
recvToken = resp.getToken();
CHECKRETURN(nRes, "ReceiverClient::CreateReceiver");
}
const char *
mfn_for(MFUNARGS)
{
int iter_limit = MAX_MFUN_LIST_LEN;
char tmp[BUFFER_LEN];
char *ptr, *dptr;
int v, i, start, end, incr;
ptr = MesgParse(argv[0],argv[0]);
CHECKRETURN(ptr,"FOR","arg 1 (varname)");
v = new_mvar(ptr, tmp);
if (v == 1)
ABORT_MPI("FOR","Variable name too long");
if (v == 2)
ABORT_MPI("FOR","Too many variables already defined");
dptr = MesgParse(argv[1],argv[1]);
CHECKRETURN(dptr,"FOR","arg 2 (start num)");
start = atoi(dptr);
dptr = MesgParse(argv[2],argv[2]);
CHECKRETURN(dptr,"FOR","arg 3 (end num)");
end = atoi(dptr);
dptr = MesgParse(argv[3],argv[3]);
CHECKRETURN(dptr,"FOR","arg 4 (increment)");
incr = atoi(dptr);
*buf = '\0';
for (i = start; ((incr>=0 && i<=end) || (incr<0 && i>=end)); i += incr) {
sprintf(tmp, "%d", i);
dptr = MesgParse(argv[4],buf);
CHECKRETURN(dptr,"FOR","arg 5 (repeated command)");
if (!(--iter_limit))
ABORT_MPI("FOR","Iteration limit exceeded");
}
free_top_mvar();
return buf;
}
int ReceiverClient::SetReceiverMode(const std::string & recvToken, bool bMode)
{
RecvSetReceiverMode req(m_proxy.soap);
RecvSetReceiverModeResponse resp(m_proxy.soap);
req.setToken(recvToken);
req.setMode(bMode);
SIGRLOG(SIGRDEBUG2, "ReceiverClient::SetReceiverMode %s %d", req.getToken().c_str(), req.getMode());
int nRes = m_proxy.SetReceiverMode(req.d, resp.d);
CHECKRETURN(nRes, "ReceiverClient::SetReceiverMode");
}
int DeviceServiceImpl::SetSystemDateAndTime(_tds__SetSystemDateAndTime *tds__SetSystemDateAndTime, _tds__SetSystemDateAndTimeResponse *tds__SetSystemDateAndTimeResponse)
{
if(tds__SetSystemDateAndTime->DateTimeType != tt__SetDateTimeType__Manual)
{
SIGRLOG(SIGRWARNING, "DeviceServiceImpl::SetSystemDateAndTime Time is not Manual");
return SOAP_ERR;
}
DevSetSystemDateAndTime dt(tds__SetSystemDateAndTime);
int nRes = m_pBaseServer->SetDateAndTime(dt);
CHECKRETURN(nRes, "DeviceServiceImpl::SetSystemDateAndTime");
}
const char *
mfn_if(MFUNARGS)
{
char *fbr, *ptr;
if (argc == 3) {
fbr = argv[2];
} else {
fbr = "";
}
ptr = MesgParse(argv[0], buf, buflen);
CHECKRETURN(ptr, "IF", "arg 1");
if (ptr && truestr(buf)) {
ptr = MesgParse(argv[1], buf, buflen);
CHECKRETURN(ptr, "IF", "arg 2");
} else if (*fbr) {
ptr = MesgParse(fbr, buf, buflen);
CHECKRETURN(ptr, "IF", "arg 3");
} else {
*buf = '\0';
ptr = "";
}
return ptr;
}
int DisplayServiceImpl::GetLayout(_tls__GetLayout *tls__GetLayout, _tls__GetLayoutResponse *tls__GetLayoutResponse)
{
DispGetLayout req(tls__GetLayout);
DispGetLayoutResponse resp(tls__GetLayoutResponse);
std::string requestedLayoutToken;
req.GetLayout(requestedLayoutToken);
int iRet = m_pBaseServer->GetLayout(requestedLayoutToken, resp);
CHECKRETURN(iRet, "DisplayServiceImpl::GetLayout");
};
const char *
mfn_and(MFUNARGS)
{
char *ptr;
char buf2[16];
int i;
for (i = 0; i < argc; i++) {
ptr = MesgParse(argv[i], buf, buflen);
snprintf(buf2, sizeof(buf2), "arg %d", i + 1);
CHECKRETURN(ptr, "AND", buf2);
if (!truestr(ptr)) {
return "0";
}
}
return "1";
}
const char *
mfn_timesub(MFUNARGS)
{
int num = 0;
dbref trg = (dbref) 0, obj = what;
const char *pname, *ptr;
int period = 0, offset = 0;
int blessed = 0;
period = atoi(argv[0]);
offset = atoi(argv[1]);
pname = argv[2];
if (argc == 4) {
obj = mesg_dbref(descr, player, what, perms, argv[3], mesgtyp);
}
if (obj == PERMDENIED)
ABORT_MPI("TIMESUB", "Permission denied.");
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("TIMESUB", "Match failed.");
num = get_list_count(what, obj, perms, (char *)pname, mesgtyp, &blessed);
if (!num)
ABORT_MPI("TIMESUB", "Failed list read.");
if (period < 1)
ABORT_MPI("TIMESUB", "Time period too short.");
offset = (int)((((long) time(NULL) + offset) % period) * num) / period;
if (offset < 0)
offset = -offset;
ptr = get_list_item(what, obj, perms, (char *)pname, offset + 1, mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("TIMESUB", "Failed list read.");
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(ptr) || Prop_Private(ptr) || Prop_SeeOnly(ptr) || Prop_Hidden(ptr))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "TIMESUB", "listval");
return ptr;
}
const char *
mfn_indexbang(MFUNARGS)
{
dbref trg = (dbref) 0, obj = what;
dbref tmpobj = (dbref) 0;
const char *pname, *ptr;
int blessed = 0;
pname = argv[0];
if (argc == 2) {
obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
}
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("INDEX!", "Match failed.");
if (obj == PERMDENIED)
ABORT_MPI("INDEX!", "Permission denied.");
tmpobj = obj;
ptr = safegetprop_strict(player, obj, perms, pname, mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("INDEX!", "Failed read.");
if (!*ptr)
return "";
obj = tmpobj;
ptr = safegetprop_strict(player, obj, perms, ptr, mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("INDEX!", "Failed read.");
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(ptr) || Prop_Private(ptr) || Prop_SeeOnly(ptr) || Prop_Hidden(ptr))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "INDEX!", "listval");
return ptr;
}
const char *
mfn_lsort(MFUNARGS)
{
char *litem[MAX_MFUN_LIST_LEN];
char vbuf[BUFFER_LEN];
char vbuf2[BUFFER_LEN];
char *ptr, *ptr2, *tmp;
int i, j, count;
if (argc > 1 && argc < 4)
ABORT_MPI("LSORT","Takes 1 or 4 arguments");
for (i = 0; i < MAX_MFUN_LIST_LEN; i++)
litem[i] = NULL;
ptr = MesgParse(argv[0],argv[0]);
CHECKRETURN(ptr,"LSORT","arg 1");
if (argc > 1) {
ptr2 = MesgParse(argv[1], argv[1]);
CHECKRETURN(ptr2,"LSORT","arg 2");
j = new_mvar(ptr2, vbuf);
if (j == 1)
ABORT_MPI("LSORT","Variable name too long");
if (j == 2)
ABORT_MPI("LSORT","Too many variables already defined");
ptr2 = MesgParse(argv[2],argv[2]);
CHECKRETURN(ptr2,"LSORT","arg 3");
j = new_mvar(ptr2, vbuf2);
if (j == 1)
ABORT_MPI("LSORT","Variable name too long");
if (j == 2)
ABORT_MPI("LSORT","Too many variables already defined");
}
count = 0;
while (*ptr) {
for (ptr2 = ptr; *ptr2 && *ptr2 != '\r'; ptr2++);
if (*ptr2 == '\r') *(ptr2++) = '\0';
litem[count++] = ptr;
ptr = ptr2;
if (count >= MAX_MFUN_LIST_LEN)
ABORT_MPI("LSORT","Iteration limit exceeded");
}
for (i = 0; i < count; i++) {
for (j = i + 1; j < count; j++) {
if (argc > 1) {
strcpy(vbuf, litem[i]);
strcpy(vbuf2, litem[j]);
ptr = MesgParse(argv[3],buf);
CHECKRETURN(ptr,"LSORT","arg 4");
if (truestr(buf)) {
tmp = litem[i];
litem[i] = litem[j];
litem[j] = tmp;
}
} else {
if (alphanum_compare(litem[i], litem[j]) > 0) {
tmp = litem[i];
litem[i] = litem[j];
litem[j] = tmp;
}
}
}
}
*buf = '\0';
for (i = 0; i < count; i++) {
if (*buf) strcat(buf, "\r");
strcat(buf, litem[i]);
}
if (argc > 1) {
free_top_mvar();
free_top_mvar();
}
return buf;
}
/**
* Handles the message sent for the creation of housing hooks in the world.
*
* This function is called whenever a housing hook should be created for a client.
*
* @return cMessage - Returns a Create Object (0x0000F745) server message.
*/
cMessage cHooks::CreatePacket()
{
cMessage cmCreate;
char szCommand[200];
RETCODE retcode;
char OwnerIDBuff[9];
DWORD OwnerID = 0x0L;
sprintf( szCommand, "SELECT OwnerID FROM houses_covenants WHERE HouseID = %d;",m_dwHouseID);
retcode = SQLPrepare( cDatabase::m_hStmt, (unsigned char *)szCommand, SQL_NTS ); CHECKRETURN(1, SQL_HANDLE_STMT, cDatabase::m_hStmt, NULL)
retcode = SQLExecute( cDatabase::m_hStmt );
retcode = SQLBindCol( cDatabase::m_hStmt, 1, SQL_C_CHAR, OwnerIDBuff, sizeof( OwnerIDBuff ), NULL ); CHECKRETURN(1, SQL_HANDLE_STMT, cDatabase::m_hStmt, 1)
// Return SQL_SUCCESS if there is a house that corresponds to the hook's HouseID
if (SQLFetch( cDatabase::m_hStmt ) == SQL_SUCCESS) {
sscanf(OwnerIDBuff,"%08x",&OwnerID);
}
retcode = SQLCloseCursor( cDatabase::m_hStmt ); CHECKRETURN(0, SQL_HANDLE_STMT, cDatabase::m_hStmt, NULL)
retcode = SQLFreeStmt( cDatabase::m_hStmt, SQL_UNBIND );
float flpScale; // Scale used in Packet being Sent
float flmScale = 0; // Model Data Scale
DWORD dwFlags1 = 0x00009081; // Flags1
/*
dwModel
0x0A8D Floor Hook
0x0A8E Wall Hook
0x0A8C Ceiling Hook
0x0A8D Yard Hook
0x0A8D Roof Hook
wModelID
0x2DB1 Floor Hook
0x25D6 Wall Hook
0x2DB2 Ceiling Hook
0x3187 Yard Hook
0x3186 Roof Hook
wIconID
0x20C0
*/
WORD tBurden = 0;
if (IsUsed == 1)
{
// cItemModels *h_model = cItemModels::FindModel(m_hook_item->GetItemModelID());
// h_model->m_wBurden //Burden (WORD, no padding)
// tBurden += h_model->m_wBurden;
}
/*
//Loop through inventory and find all items.
for (int i = 0; i < this->m_hook_lstInventory.size(); i++)
{
//Find each item by it's GUID
cObject *v_item = this->FindInventory(this->v_guids[i]);
//Associate model with item
cItemModels *v_model = cItemModels::FindModel(v_item->GetItemModelID());
// v_item->GetGUID() //Item GUID
// v_model->m_dwFlags2 //10254018
// v_model->m_strName.c_str() //Item Name
// v_model->m_wModel //Model
// v_model->m_wIcon //Icon
// v_model->m_wBurden //Burden (WORD, no padding)
// v_model->m_wHooks; //Hook Type (WORD, no padding)
}
*/
cmCreate << 0xF745L
<< m_dwGUID
<< BYTE( 0x11 )
<< BYTE( 0 )
<< BYTE( 0 )
<< BYTE( 0 );
cmCreate << dwFlags1;
cmCreate << WORD(0x0014); // Type of portal
cmCreate << WORD(0x0000); // Unknown
//Flags1 Mask: 0x00009081
{
//Flags1 & 0x00008000 -- Location
cmCreate.pasteData( (UCHAR*)&m_Location, sizeof(m_Location) ); //Next comes the location
//Flags1 & 0x00001000 -- DWORD ResourceID
cmCreate << 0x3400002B; // unknown ResourceID
//Flags1 & 0x00000001 -- DWORD dwModel = 0x02000001; // the model.
DWORD dwModel = 0x02000000L + m_dwModel;
cmCreate << dwModel;
//Flags1 & 0x00000080 -- unknown_green
if (flmScale > 0)
{
flpScale = flmScale;// FLOAT flpScale
}
else
{
flpScale = 0.5;
}
cmCreate << flpScale;
}
// SeaGreens
WORD wUnkFlag2 = 0x0000;
WORD wUnkFlag3 = 0x0002;
WORD wUnkFlag4 = 0x0000;
WORD wUnkFlag6 = 0x0000;
WORD wUnkFlag7 = 0x0000;
WORD wUnkFlag8 = 0x0000;
WORD wUnkFlag10 = 0x0000;
cmCreate << m_wPositionSequence // movement 0x0001
<< wUnkFlag2 // animations
<< wUnkFlag3 // bubble modes
<< wUnkFlag4 // num jumps
<< m_wNumPortals
<< wUnkFlag6 // anim count
<< wUnkFlag7 // overrides
<< wUnkFlag8
<< WORD(0x7A51) // m_wNumLogins // 0x0D4B
<< wUnkFlag10;
DWORD dwFlags2 = 0x3220003A; // Flags2 -- Defines what data comes next
cmCreate << dwFlags2;
cmCreate << Name( ); // Object's Name
cmCreate << WORD(m_wModel) << WORD(m_wIcon);
DWORD dwObjectFlags1 = 0x00000200; // 0x0200 Containers
DWORD dwObjectFlags2 = 0x00000015; // 0x0010 is not an npc; 0x0004 cannot be picked up; 0x0001 can be opened (false if locked)
cmCreate << dwObjectFlags1 << dwObjectFlags2;
// Flags2 & 0x00000002 -- BYTE itemSlots
cmCreate << BYTE(0x01); // number of item slots
// Flags2 & 0x00000008 -- BYTE value
cmCreate << BYTE(0x0A); // object value
// Flags2 & 0x00000010 -- DWORD unknown10
cmCreate << 0x30000000L;
// Unknown
cmCreate << BYTE( 0 )
<< BYTE( 0 )
<< BYTE( 0 );
// Flags2 & 0x00000020 -- float approachDistance
float flApproach = 10.0f; // 0x41200000
cmCreate << flApproach; // distance a player will walk to use the object
// Flags2 & 0x00200000 -- WORD burden
tBurden += WORD(0x0005);
cmCreate << tBurden; // total burden of this object
// Flags2 & 0x02000000 -- ObjectID owner
cmCreate << OwnerID; // the owner of this object
// Flags2 & 0x20000000 -- hookType Unknown
cmCreate << WORD(0xFFFF); // always -1
// Flags2 & 0x10000000 -- hookable On
/*
0x0001 floor hook
0x0002 wall hook
0x0004 ceiling hook
0x0008 yard hook
0x0010 roof hook
*/
cmCreate << WORD(0xFFFF); // the types of hooks this object may be placed on (-1 for hooks)
return cmCreate;
}
/* Main method. */
int main (int argc, const char * argv[])
{
kern_return_t err;
mach_port_t masterPort = 0;
bool suspend;
SInt32 productId, vendorId;
SInt32 count;
CFMutableDictionaryRef matcher;
CFNumberRef numberRef;
io_iterator_t iterator;
io_service_t usbService;
IOCFPlugInInterface **pluginInterface;
IOUSBDeviceInterface245 **deviceInterface;
SInt32 score;
// Display usage info
if(argc != 4)
{
printf("Usage:\n"
" usbpower suspend <product id> <vendor id>\n"
" usbpower resume <product id> <vendor id>\n"
"\n"
"Vendor and product IDs can be obtained by running the command:\n"
" system_profiler SPUSBDataType\n"
"\n"
"They must be given as four-digit hexadecimal numbers beginning with 0x\n"
"(as shown by the above command).\n"
"\n"
"Example:\n"
" usbpower suspend 0x0040 0x045e\n"
"\n"
"Copyright 2009 Samuel Marshall - http://www.leafdigital.com/software/\n"
"Released under Gnu Public License v3.\n");
return 0;
}
// Check first parameter
if(strcmp(argv[1], "suspend") == 0)
{
suspend = true;
}
else if(strcmp(argv[1], "resume") == 0)
{
suspend = false;
}
else
{
fprintf(stderr, "Invalid argument '%s': expecting suspend, resume\n", argv[1]);
return -1;
}
// Check other two parameters
productId = convertHexId(argv[2]);
if(productId == -1)
{
fprintf(stderr, "Invalid product id '%s': expecting four-digit hexadecimal e.g. 0x0040\n", argv[2]);
return -1;
}
vendorId = convertHexId(argv[3]);
if(vendorId == -1)
{
fprintf(stderr, "Invalid vendor id '%s': expecting four-digit hexadecimal e.g. 0x045e\n", argv[3]);
return -1;
}
// Allocate master IO port
err = IOMasterPort(MACH_PORT_NULL, &masterPort);
CHECKRETURN(err, "Failed to open master port");
// Create matching dictionary
matcher = IOServiceMatching(kIOUSBDeviceClassName);
if(!matcher)
{
fprintf(stderr, "Failed to create matching dictionary\n");
return -1;
}
// Create number references and add to dictionary
numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &productId);
if(!numberRef)
{
fprintf(stderr, "Failed to create number reference for product ID\n");
return -1;
}
CFDictionaryAddValue(matcher, CFSTR(kUSBProductID), numberRef);
CFRelease(numberRef);
numberRef = 0;
numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &vendorId);
if(!numberRef)
{
fprintf(stderr, "Failed to create number reference for vendor ID\n");
return -1;
}
CFDictionaryAddValue(matcher, CFSTR(kUSBVendorID), numberRef);
CFRelease(numberRef);
numberRef = 0;
// Get matches from dictionary (this eats the dictionary)
err = IOServiceGetMatchingServices(masterPort, matcher, &iterator);
CHECKRETURN(err, "Failed to get matching servivces");
matcher = 0;
count = 0;
while((usbService = IOIteratorNext(iterator)))
{
// Get plugin interface
err = IOCreatePlugInInterfaceForService(
usbService, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &pluginInterface, &score);
CHECKRETURN(err, "Failed to create plugin interface for service");
if(!pluginInterface)
{
fprintf(stderr, "Service did not return plugin interface\n");
return -1;
}
// Now query for suitable USB device interface
err = (*pluginInterface)->QueryInterface(pluginInterface,
CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245), (LPVOID)&deviceInterface);
IODestroyPlugInInterface(pluginInterface);
// Open device
err = (*deviceInterface)->USBDeviceOpen(deviceInterface);
CHECKRETURN(err, "Error opening device");
// Suspend or resume device
err = (*deviceInterface)->USBDeviceSuspend(deviceInterface, suspend);
CHECKRETURN(err, "Error suspending or resuming device");
// Close device
err = (*deviceInterface)->USBDeviceClose(deviceInterface);
CHECKRETURN(err, "Error closing device");
err = (*deviceInterface)->Release(deviceInterface);
CHECKRETURN(err, "Error releading device interface");
// Release service
IOObjectRelease(usbService);
count++;
}
// Release iterator
IOObjectRelease(iterator);
iterator = 0;
// Free master IO port
mach_port_deallocate(mach_task_self(), masterPort);
// Check count
if(!count)
{
fprintf(stderr, "Device with product ID 0x%04x and vendor ID 0x%04x not found\n", productId, vendorId);
return -1;
}
return 0;
}
