void update_persistent_room_change(const char *info) {
ROOM_DATA *room = NULL;
hookParseInfo(info, &room);
if(roomIsPersistent(room) && !roomIsExtracted(room) &&
!roomIsPersistentDirty(room)) {
listPut(p_to_save, room);
roomSetPersistentDirty(room);
}
}
void update_persistent_obj_from_room(const char *info) {
OBJ_DATA *obj = NULL;
ROOM_DATA *room = NULL;
hookParseInfo(info, &obj, &room);
if(roomIsPersistent(room)&& !roomIsExtracted(room)&&
!roomIsPersistentDirty(room)) {
listPut(p_to_save, room);
roomSetPersistentDirty(room);
}
}
void update_persistent_char_from_room(const char *info) {
CHAR_DATA *ch = NULL;
ROOM_DATA *room = NULL;
hookParseInfo(info, &ch, &room);
if(charIsNPC(ch) && roomIsPersistent(room) && !roomIsExtracted(room) &&
!roomIsPersistentDirty(room)) {
listPut(p_to_save, room);
roomSetPersistentDirty(room);
}
}
void PyRoom_addMethod(const char *name, void *f, int flags, const char *doc) {
// make sure our list of methods is created
if(pyroom_methods == NULL) pyroom_methods = newList();
// make the Method def
PyMethodDef *def = calloc(1, sizeof(PyMethodDef));
def->ml_name = strdup(name);
def->ml_meth = (PyCFunction)f;
def->ml_flags = flags;
def->ml_doc = (doc ? strdup(doc) : NULL);
listPut(pyroom_methods, def);
}
void PyRoom_addGetSetter(const char *name, void *g, void *s, const char *doc) {
// make sure our list of get/setters is created
if(pyroom_getsetters == NULL) pyroom_getsetters = newList();
// make the GetSetter def
PyGetSetDef *def = calloc(1, sizeof(PyGetSetDef));
def->name = strdup(name);
def->get = (getter)g;
def->set = (setter)s;
def->doc = (doc ? strdup(doc) : NULL);
def->closure = NULL;
listPut(pyroom_getsetters, def);
}
//
// prepare a persistent room to be saved to disc
PyObject *PyRoom_dirtyPersistence(PyObject *pyroom) {
ROOM_DATA *room = PyRoom_AsRoom(pyroom);
if(room == NULL) {
PyErr_Format(PyExc_TypeError, "tried to dirty nonexistent room.");
return NULL;
}
// if we're not persistent, ignore
if(!roomIsPersistent(room))
return Py_BuildValue("i", 0);
else if(!roomIsPersistentDirty(room)) {
listPut(p_to_save, room);
roomSetPersistentDirty(room);
}
return Py_BuildValue("");
}
void update_persistent_obj_to_obj(const char *info) {
OBJ_DATA *obj = NULL;
OBJ_DATA *container = NULL;
ROOM_DATA *root = NULL;
hookParseInfo(info, &obj, &container);
if(container == NULL || obj == NULL)
return;
root = objGetRootRoom(container);
if(root == NULL)
return;
if(roomIsPersistent(root) && !roomIsExtracted(root) &&
!roomIsPersistentDirty(root)) {
listPut(p_to_save, root);
roomSetPersistentDirty(root);
}
}
//
// save all of the socials to disk
//
void save_socials() {
STORAGE_SET *set = new_storage_set();
LIST *soc_list = newList();
// iterate across the social table and save all of the unique socials
HASH_ITERATOR *hash_i = newHashIterator(social_table);
const char *cmd = NULL;
SOCIAL_DATA *data = NULL;
ITERATE_HASH(cmd, data, hash_i)
listPut(soc_list, data);
deleteHashIterator(hash_i);
store_list(set, "socials", gen_store_list(soc_list, socialStore));
deleteList(soc_list);
// write the set
storage_write(set, SOCIALS_FILE);
// close the set
storage_close(set);
}
void obj_to_game(OBJ_DATA *obj) {
if(setIn(object_set, obj))
return;
// property table, for lookup by python
if(!obj_exists(obj))
obj_exist(obj);
// set and list storage, for objects physically 'in' the game
listPut(object_list, obj);
setPut(object_set, obj);
// execute all of our to_game hooks
hookRun("obj_to_game", hookBuildInfo("obj", obj));
// also add all contents
if(listSize(objGetContents(obj)) > 0) {
LIST_ITERATOR *cont_i = newListIterator(objGetContents(obj));
OBJ_DATA *cont = NULL;
ITERATE_LIST(cont, cont_i)
obj_to_game(cont);
deleteListIterator(cont_i);
}
}
void resetAddOn (RESET_DATA *reset, RESET_DATA *on) {
listPut(reset->on, on);
}
//
// generalized function for setting up a dictionary and running a trigger. The
// common types of variables can be supplied in the function. Additional ones
// can be added in the optional list, which must be deleted after use
void gen_do_trig(TRIGGER_DATA *trig,
void *me, int me_type, CHAR_DATA *ch, OBJ_DATA *obj,
ROOM_DATA *room, EXIT_DATA *exit, const char *command,
const char *arg, LIST *optional) {
// make our basic dictionary, and fill it up with these new variables
PyObject *dict = restricted_script_dict();
LIST *varnames = newList();
// now, import all of our variables
if(command) {
PyObject *pycmd = PyString_FromString(command);
PyDict_SetItemString(dict, "cmd", pycmd);
listPut(varnames, strdup("cmd"));
Py_DECREF(pycmd);
}
if(arg) {
PyObject *pyarg = PyString_FromString(arg);
PyDict_SetItemString(dict, "arg", pyarg);
listPut(varnames, strdup("arg"));
Py_DECREF(pyarg);
}
if(ch) {
PyObject *pych = charGetPyForm(ch);
PyDict_SetItemString(dict, "ch", pych);
listPut(varnames, strdup("ch"));
Py_DECREF(pych);
}
if(room) {
PyObject *pyroom = roomGetPyForm(room);
PyDict_SetItemString(dict, "room", pyroom);
listPut(varnames, strdup("room"));
Py_DECREF(pyroom);
}
if(obj) {
PyObject *pyobj = objGetPyForm(obj);
PyDict_SetItemString(dict, "obj", pyobj);
listPut(varnames, strdup("obj"));
Py_DECREF(pyobj);
}
if(exit) {
PyObject *pyexit = newPyExit(exit);
PyDict_SetItemString(dict, "ex", pyexit);
listPut(varnames, strdup("ex"));
Py_DECREF(pyexit);
}
// add the thing the trigger is attached to
if(me) {
PyObject *pyme = NULL;
switch(me_type) {
case TRIGVAR_CHAR: pyme = charGetPyForm(me); break;
case TRIGVAR_OBJ: pyme = objGetPyForm(me); break;
case TRIGVAR_ROOM: pyme = roomGetPyForm(me); break;
}
PyDict_SetItemString(dict, "me", pyme);
listPut(varnames, strdup("me"));
Py_DECREF(pyme);
}
// now, add any optional variables
if(optional) {
LIST_ITERATOR *opt_i = newListIterator(optional);
OPT_VAR *opt = NULL;
PyObject *pyopt = NULL;
ITERATE_LIST(opt, opt_i) {
pyopt = NULL;
switch(opt->type) {
case TRIGVAR_CHAR: pyopt = charGetPyForm(opt->data); break;
case TRIGVAR_OBJ: pyopt = objGetPyForm(opt->data); break;
case TRIGVAR_ROOM: pyopt = roomGetPyForm(opt->data); break;
}
PyDict_SetItemString(dict, opt->name, pyopt);
listPut(varnames, strdup(opt->name));
Py_XDECREF(pyopt);
} deleteListIterator(opt_i);
}
/*
* New_socket()
*
* Initializes a new socket, get's the hostname
* and puts it in the active socket_list.
*/
SOCKET_DATA *new_socket(int sock)
{
struct sockaddr_in sock_addr;
pthread_attr_t attr;
pthread_t thread_lookup;
LOOKUP_DATA * lData;
SOCKET_DATA * sock_new;
int argp = 1;
socklen_t size;
/* initialize threads */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
/* create and clear the socket */
sock_new = calloc(1, sizeof(SOCKET_DATA));
/* attach the new connection to the socket list */
FD_SET(sock, &fSet);
/* clear out the socket */
clear_socket(sock_new, sock);
sock_new->closed = FALSE;
/* set the socket as non-blocking */
ioctl(sock, FIONBIO, &argp);
/* update the socket list and table */
listPut(socket_list, sock_new);
propertyTablePut(sock_table, sock_new);
/* do a host lookup */
size = sizeof(sock_addr);
if (getpeername(sock, (struct sockaddr *) &sock_addr, &size) < 0)
{
perror("New_socket: getpeername");
sock_new->hostname = strdup("unknown");
}
else
{
/* set the IP number as the temporary hostname */
sock_new->hostname = strdup(inet_ntoa(sock_addr.sin_addr));
if (!compares(sock_new->hostname, "127.0.0.1"))
{
/* allocate some memory for the lookup data */
if ((lData = malloc(sizeof(*lData))) == NULL)
{
bug("New_socket: Cannot allocate memory for lookup data.");
abort();
}
/* Set the lookup_data for use in lookup_address() */
lData->buf = strdup((char *) &sock_addr.sin_addr);
lData->dsock = sock_new;
/* dispatch the lookup thread */
pthread_create(&thread_lookup, &attr, &lookup_address, (void*) lData);
}
else sock_new->lookup_status++;
}
/* negotiate compression */
// text_to_buffer(sock_new, (char *) compress_will2);
// text_to_buffer(sock_new, (char *) compress_will);
/* send the greeting */
// text_to_buffer(sock_new, bufferString(greeting));
/* everything went as it was supposed to */
return sock_new;
}
PyObject *py_gen_do_trigs(PyObject *self, PyObject *args, PyObject *kwds) {
static char *kwlist[] ={ "type","ch","obj","room","exit","cmd","arg","opts",NULL };
char *type = NULL;
char *cmd = NULL;
char *arg = NULL;
PyObject *pych = NULL;
PyObject *pyobj = NULL;
PyObject *pyroom = NULL;
PyObject *pyexit = NULL;
PyObject *pyopts = NULL;
LIST *opts = NULL;
CHAR_DATA *ch = NULL;
OBJ_DATA *obj = NULL;
ROOM_DATA *room = NULL;
EXIT_DATA *exit = NULL;
void *me = NULL;
int me_type = -1;
bool fail = FALSE;
// first, parse all of our arguments
if(!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOOssO", kwlist,
&type, &pych, &pyobj, &pyroom, &pyexit,
&cmd, &arg, &pyopts)) {
PyErr_Format(PyExc_TypeError, "do_trigs supplied invalid arguments.");
return NULL;
}
// make sure we exist, and are of a valid type
if(PyChar_Check(self)) {
me = PyChar_AsChar(self);
me_type = TRIGVAR_CHAR;
}
else if(PyObj_Check(self)) {
me = PyObj_AsObj(self);
me_type = TRIGVAR_OBJ;
}
else if(PyRoom_Check(self)) {
me = PyRoom_AsRoom(self);
me_type = TRIGVAR_ROOM;
}
// did we find a character?
if(me == NULL) {
PyErr_Format(PyExc_TypeError,"do_trigs owner does not exist.");
return NULL;
}
// make sure ch is of the specified type
if(pych!=NULL && (!PyChar_Check(pych) || (ch=PyChar_AsChar(pych)) == NULL)){
PyErr_Format(PyExc_TypeError,"do_trigs expects ch to be character.");
return NULL;
}
// make sure obj is of the specified type
if(pyobj!=NULL && (!PyObj_Check(pyobj) || (obj=PyObj_AsObj(pyobj)) == NULL)){
PyErr_Format(PyExc_TypeError,"do_trigs expects obj to be object.");
return NULL;
}
// make sure room is of the specified type
if(pyroom!=NULL&&(!PyRoom_Check(pyroom)||(room=PyRoom_AsRoom(pyroom))==NULL)){
PyErr_Format(PyExc_TypeError,"do_trigs expects room to be room.");
return NULL;
}
// make sure exit is of the specified type
if(pyexit!=NULL&&(!PyExit_Check(pyexit)||(exit=PyExit_AsExit(pyexit))==NULL)){
PyErr_Format(PyExc_TypeError,"do_trigs expects exit to be an exit.");
return NULL;
}
// parse opts
if(pyopts != NULL && !PyDict_Check(pyopts)) {
PyErr_Format(PyExc_TypeError,"do_trigs expects opts to be a dict.");
return NULL;
}
else if(pyopts != NULL) {
PyObject *pairs = PyDict_Items(pyopts);
int i = 0;
opts = newList();
// go through each pair and add it to the pyopts list
for(; i < PyList_Size(pairs); i++) {
PyObject *pair = PyList_GetItem(pairs, i);
PyObject *pykey = PyTuple_GetItem(pair, 0);
PyObject *pyval = PyTuple_GetItem(pair, 1);
OPT_VAR *opt = NULL;
char *key = NULL;
// make sure the key is a string
if(PyString_Check(pykey))
key = PyString_AsString(pykey);
else {
PyErr_Format(PyExc_TypeError, "do_trigs opt keys must be strings.");
fail = TRUE;
break;
}
// check to make sure the val is a valid type
if(PyChar_Check(pyval)) {
CHAR_DATA *val = PyChar_AsChar(pyval);
if(val != NULL)
opt = newOptVar(key, val, TRIGVAR_CHAR);
else {
PyErr_Format(PyExc_TypeError,"%s opt provided nonexistent char.",key);
fail = TRUE;
break;
}
}
else if(PyObj_Check(pyval)) {
OBJ_DATA *val = PyObj_AsObj(pyval);
if(val != NULL)
opt = newOptVar(key, val, TRIGVAR_OBJ);
else {
PyErr_Format(PyExc_TypeError,"%s opt provided nonexistent obj.", key);
fail = TRUE;
break;
}
}
else if(PyRoom_Check(pyval)) {
ROOM_DATA *val = PyRoom_AsRoom(pyval);
if(val != NULL)
opt = newOptVar(key, val, TRIGVAR_ROOM);
else {
PyErr_Format(PyExc_TypeError,"%s opt provided nonexistent room.",key);
fail = TRUE;
break;
}
}
else {
PyErr_Format(PyExc_TypeError,"%s opt provided invalid value.",key);
fail = TRUE;
break;
}
// append the opt to the opt list
listPut(opts, opt);
}
Py_DECREF(pairs);
}
// did everything succeed?
if(fail == FALSE)
gen_do_trigs(me,me_type,type,ch,obj,room,exit,cmd,arg,opts);
// garbage collection
if(opts != NULL)
deleteListWith(opts, deleteOptVar);
if(fail == TRUE)
return NULL;
return Py_BuildValue("");
}
void resetListAdd(RESET_LIST *list, RESET_DATA *reset) {
listPut(list->resets, reset);
}
void resetAddThen (RESET_DATA *reset, RESET_DATA *then) {
listPut(reset->then, then);
}
void resetAddIn (RESET_DATA *reset, RESET_DATA *in) {
listPut(reset->in, in);
}
/* Recover from a copyover - load players */
void copyover_recover() {
CHAR_DATA *dMob;
ACCOUNT_DATA *account;
SOCKET_DATA *dsock;
FILE *fp;
char acct[100];
char name[100];
char host[MAX_BUFFER];
int desc;
log_string("Copyover recovery initiated");
if ((fp = fopen(COPYOVER_FILE, "r")) == NULL) {
log_string("Copyover file not found. Exitting.");
exit (1);
}
/* In case something crashes - doesn't prevent reading */
unlink(COPYOVER_FILE);
for (;;) {
fscanf(fp, "%d %s %s %s\n", &desc, acct, name, host);
if (desc == -1)
break;
// Many thanks to Rhaelar for the help in finding this bug; clear_socket
// does not like receiving freshly malloc'd data. We have to make sure
// everything is zeroed before we pass it to clear_socket
// dsock = malloc(sizeof(*dsock));
dsock = calloc(1, sizeof(*dsock));
clear_socket(dsock, desc);
dsock->hostname = strdup(host);
listPut(socket_list, dsock);
propertyTablePut(sock_table, dsock);
// load account data
if((account = get_account(acct)) != NULL)
socketSetAccount(dsock, account);
// no luck!
else {
close_socket(dsock, FALSE);
continue;
}
// load player data
if ((dMob = get_player(name)) != NULL) {
// attach to socket
charSetSocket(dMob, dsock);
socketSetChar(dsock, dMob);
// try putting the character into the game
// close the socket if we fail.
if(!try_enter_game(dMob)) {
// do not bother extracting, since we haven't entered the game yet
unreference_player(socketGetChar(dsock));
socketSetChar(dsock, NULL);
close_socket(dsock, FALSE);
continue;
}
}
// no luck
else {
close_socket(dsock, FALSE);
continue;
}
// Write something, and check if it goes error-free
if (!text_to_socket(dsock, "\n\r <*> And before you know it, everything has changed <*>\n\r")) {
close_socket(dsock, FALSE);
continue;
}
// make sure the socket can be used
dsock->bust_prompt = TRUE;
dsock->lookup_status = TSTATE_DONE;
// let our modules know we've finished copying over a socket
hookRun("copyover_complete", hookBuildInfo("sk", dsock));
// negotiate compression
text_to_buffer(dsock, (char *) compress_will2);
text_to_buffer(dsock, (char *) compress_will);
}
fclose(fp);
// now, set all of the sockets' control to the new fSet
reconnect_copyover_sockets();
}
void input_handler() {
LIST_ITERATOR *sock_i = newListIterator(socket_list);
SOCKET_DATA *sock = NULL;
ITERATE_LIST(sock, sock_i) {
// Close sockects we are unable to read from, or if we have no handler
// to take in input
if ((FD_ISSET(sock->control, &rFd) && !read_from_socket(sock)) ||
listSize(sock->input_handlers) == 0) {
close_socket(sock, FALSE);
continue;
}
/* Ok, check for a new command */
next_cmd_from_buffer(sock);
// are we idling?
if(!sock->cmd_read)
sock->idle += 1.0 / PULSES_PER_SECOND;
/* Is there a new command pending ? */
else if (sock->cmd_read) {
sock->idle = 0.0;
IH_PAIR *pair = listGet(sock->input_handlers, 0);
if(pair->python == FALSE) {
void (* handler)(SOCKET_DATA *, char *) = pair->handler;
char *cmddup = strdup(bufferString(sock->next_command));
handler(sock, cmddup);
free(cmddup);
}
else {
PyObject *arglist = Py_BuildValue("Os", socketGetPyFormBorrowed(sock),
bufferString(sock->next_command));
PyObject *retval = PyEval_CallObject(pair->handler, arglist);
// check for an error:
if(retval == NULL)
log_pyerr("Error with a Python input handler");
// garbage collection
Py_XDECREF(retval);
Py_XDECREF(arglist);
}
// append our last command to the command history. History buffer is
// 100 commands, so pop off the earliest command if we're going over
listPut(sock->command_hist, strdup(bufferString(sock->next_command)));
if(listSize(sock->command_hist) > 100)
free(listRemoveNum(sock->command_hist, 100));
bufferClear(sock->next_command);
// we save whether or not we read a command until our next call to
// input_handler(), at which time it is reset to FALSE if we didn't read
// sock->cmd_read = FALSE;
}
#ifdef MODULE_ALIAS
// ACK!! this is so yucky, but I can't think of a better way to do it...
// if this command was put in place by an alias, decrement the alias_queue
// counter by one. This counter is in place mainly so aliases do not end
// up calling eachother and making us get stuck in an infinite loop.
if(sock->player) {
int alias_queue = charGetAliasesQueued(sock->player);
if(alias_queue > 0)
charSetAliasesQueued(sock->player, --alias_queue);
}
#endif
} deleteListIterator(sock_i);
}
