From 069f39e8a1ebee3e4a4ce8302d0099842876782b Mon Sep 17 00:00:00 2001 From: Ben Longbons Date: Thu, 13 Dec 2012 16:25:50 -0800 Subject: Some formatting fixes before I go insane Also delete the French translation from ladmin. --- src/common/core.cpp | 48 ++++++------ src/common/core.hpp | 4 +- src/common/db.cpp | 126 +++++++++++++++--------------- src/common/db.hpp | 30 ++++---- src/common/grfio.cpp | 84 ++++++++++---------- src/common/grfio.hpp | 6 +- src/common/lock.cpp | 18 ++--- src/common/lock.hpp | 4 +- src/common/md5calc.cpp | 2 +- src/common/md5calc.hpp | 8 +- src/common/mmo.hpp | 44 +++++------ src/common/mt_rand.cpp | 16 ++-- src/common/mt_rand.hpp | 4 +- src/common/nullpo.cpp | 38 +++++----- src/common/nullpo.hpp | 12 +-- src/common/socket.cpp | 202 ++++++++++++++++++++++++------------------------- src/common/socket.hpp | 32 ++++---- src/common/timer.cpp | 76 +++++++++---------- src/common/timer.hpp | 18 ++--- src/common/utils.cpp | 38 +++++----- src/common/utils.hpp | 8 +- 21 files changed, 409 insertions(+), 409 deletions(-) (limited to 'src/common') diff --git a/src/common/core.cpp b/src/common/core.cpp index db26e31..9d1d8e7 100644 --- a/src/common/core.cpp +++ b/src/common/core.cpp @@ -17,13 +17,13 @@ // (sigaction() is POSIX; signal() is not.) Taken from Stevens' _Advanced // Programming in the UNIX Environment_. // -typedef void (*sigfunc)(int); -static sigfunc compat_signal (int signo, sigfunc func) +typedef void(*sigfunc)(int); +static sigfunc compat_signal(int signo, sigfunc func) { struct sigaction sact, oact; sact.sa_handler = func; - sigfillset (&sact.sa_mask); + sigfillset(&sact.sa_mask); sigdelset(&sact.sa_mask, SIGSEGV); sigdelset(&sact.sa_mask, SIGBUS); sigdelset(&sact.sa_mask, SIGTRAP); @@ -31,22 +31,22 @@ static sigfunc compat_signal (int signo, sigfunc func) sigdelset(&sact.sa_mask, SIGFPE); sact.sa_flags = 0; - if (sigaction (signo, &sact, &oact) < 0) + if (sigaction(signo, &sact, &oact) < 0) return SIG_ERR; return oact.sa_handler; } -static void chld_proc (int UNUSED) +static void chld_proc(int UNUSED) { wait(NULL); } -static void sig_proc (int UNUSED) +static void sig_proc(int UNUSED) { for (int i = 1; i < 31; ++i) compat_signal(i, SIG_IGN); - term_func (); - _exit (0); + term_func(); + _exit(0); } bool runflag = true; @@ -60,34 +60,34 @@ bool runflag = true; Unless you use SA_SIGINFO and *carefully* check the origin, that means they must be SIG_DFL. */ -int main (int argc, char **argv) +int main(int argc, char **argv) { /// Note that getpid() and getppid() may be very close - mt_seed (time (NULL) ^ (getpid () << 16) ^ (getppid () << 8)); + mt_seed(time(NULL) ^ (getpid() << 16) ^ (getppid() << 8)); - do_socket (); + do_socket(); - do_init (argc, argv); + do_init(argc, argv); // set up exit handlers *after* the initialization has happened. // This is because term_func is likely to depend on successful init. - compat_signal (SIGPIPE, SIG_IGN); - compat_signal (SIGTERM, sig_proc); - compat_signal (SIGINT, sig_proc); - compat_signal (SIGCHLD, chld_proc); + compat_signal(SIGPIPE, SIG_IGN); + compat_signal(SIGTERM, sig_proc); + compat_signal(SIGINT, sig_proc); + compat_signal(SIGCHLD, chld_proc); // Signal to create coredumps by system when necessary (crash) - compat_signal (SIGSEGV, SIG_DFL); - compat_signal (SIGBUS, SIG_DFL); - compat_signal (SIGTRAP, SIG_DFL); - compat_signal (SIGILL, SIG_DFL); - compat_signal (SIGFPE, SIG_DFL); + compat_signal(SIGSEGV, SIG_DFL); + compat_signal(SIGBUS, SIG_DFL); + compat_signal(SIGTRAP, SIG_DFL); + compat_signal(SIGILL, SIG_DFL); + compat_signal(SIGFPE, SIG_DFL); - atexit (term_func); + atexit(term_func); while (runflag) { - do_sendrecv (do_timer (gettick_nocache ())); - do_parsepacket (); + do_sendrecv(do_timer(gettick_nocache())); + do_parsepacket(); } } diff --git a/src/common/core.hpp b/src/common/core.hpp index 8a52c55..14dc61d 100644 --- a/src/common/core.hpp +++ b/src/common/core.hpp @@ -10,10 +10,10 @@ extern bool runflag; /// This is an external function defined by each server /// This function must register stuff for the parse loop -extern int do_init (int, char **); +extern int do_init(int, char **); /// Cleanup function called whenever a signal kills us /// or when if we manage to exit() gracefully. -extern void term_func (void); +extern void term_func(void); #endif // CORE_HPP diff --git a/src/common/db.cpp b/src/common/db.cpp index 21a3597..e04b7d0 100644 --- a/src/common/db.cpp +++ b/src/common/db.cpp @@ -8,14 +8,14 @@ #define ROOT_SIZE 4096 -static int strdb_cmp (struct dbt *table, const char *a, const char* b) +static int strdb_cmp(struct dbt *table, const char *a, const char* b) { if (table->maxlen) - return strncmp (a, b, table->maxlen); - return strcmp (a, b); + return strncmp(a, b, table->maxlen); + return strcmp(a, b); } -static hash_t strdb_hash (struct dbt *table, const char *a) +static hash_t strdb_hash(struct dbt *table, const char *a) { size_t i = table->maxlen; if (i == 0) @@ -29,16 +29,16 @@ static hash_t strdb_hash (struct dbt *table, const char *a) return h; } -struct dbt *strdb_init (size_t maxlen) +struct dbt *strdb_init(size_t maxlen) { struct dbt *table; - CREATE (table, struct dbt, 1); + CREATE(table, struct dbt, 1); table->type = DB_STRING; table->maxlen = maxlen; return table; } -static int numdb_cmp (numdb_key_t a, numdb_key_t b) +static int numdb_cmp(numdb_key_t a, numdb_key_t b) { if (a == b) return 0; @@ -47,47 +47,47 @@ static int numdb_cmp (numdb_key_t a, numdb_key_t b) return 1; } -static hash_t numdb_hash (numdb_key_t a) +static hash_t numdb_hash(numdb_key_t a) { return (hash_t) a; } -struct dbt *numdb_init (void) +struct dbt *numdb_init(void) { struct dbt *table; - CREATE (table, struct dbt, 1); + CREATE(table, struct dbt, 1); table->type = DB_NUMBER; return table; } -static int table_cmp (struct dbt *table, db_key_t a, db_key_t b) +static int table_cmp(struct dbt *table, db_key_t a, db_key_t b) { - switch(table->type) + switch (table->type) { - case DB_NUMBER: return numdb_cmp (a.i, b.i); - case DB_STRING: return strdb_cmp (table, a.s, b.s); + case DB_NUMBER: return numdb_cmp(a.i, b.i); + case DB_STRING: return strdb_cmp(table, a.s, b.s); } abort(); } -static hash_t table_hash (struct dbt *table, db_key_t key) +static hash_t table_hash(struct dbt *table, db_key_t key) { - switch(table->type) + switch (table->type) { - case DB_NUMBER: return numdb_hash (key.i); - case DB_STRING: return strdb_hash (table, key.s); + case DB_NUMBER: return numdb_hash(key.i); + case DB_STRING: return strdb_hash(table, key.s); } abort(); } /// Search for a node with the given key -db_val_t db_search (struct dbt *table, db_key_t key) +db_val_t db_search(struct dbt *table, db_key_t key) { - struct dbn *p = table->ht[table_hash (table, key) % HASH_SIZE]; + struct dbn *p = table->ht[table_hash(table, key) % HASH_SIZE]; while (p) { - int c = table_cmp (table, key, p->key); + int c = table_cmp(table, key, p->key); if (c == 0) return p->data; if (c < 0) @@ -99,7 +99,7 @@ db_val_t db_search (struct dbt *table, db_key_t key) } // Tree maintainance methods -static void db_rotate_left (struct dbn *p, struct dbn **root) +static void db_rotate_left(struct dbn *p, struct dbn **root) { struct dbn *y = p->right; p->right = y->left; @@ -117,7 +117,7 @@ static void db_rotate_left (struct dbn *p, struct dbn **root) p->parent = y; } -static void db_rotate_right (struct dbn *p, struct dbn **root) +static void db_rotate_right(struct dbn *p, struct dbn **root) { struct dbn *y = p->left; p->left = y->right; @@ -135,7 +135,7 @@ static void db_rotate_right (struct dbn *p, struct dbn **root) p->parent = y; } -static void db_rebalance (struct dbn *p, struct dbn **root) +static void db_rebalance(struct dbn *p, struct dbn **root) { p->color = RED; while (p != *root && p->parent->color == RED) @@ -155,11 +155,11 @@ static void db_rebalance (struct dbn *p, struct dbn **root) if (p == p->parent->right) { p = p->parent; - db_rotate_left (p, root); + db_rotate_left(p, root); } p->parent->color = BLACK; p->parent->parent->color = RED; - db_rotate_right (p->parent->parent, root); + db_rotate_right(p->parent->parent, root); } } else @@ -177,11 +177,11 @@ static void db_rebalance (struct dbn *p, struct dbn **root) if (p == p->parent->left) { p = p->parent; - db_rotate_right (p, root); + db_rotate_right(p, root); } p->parent->color = BLACK; p->parent->parent->color = RED; - db_rotate_left (p->parent->parent, root); + db_rotate_left(p->parent->parent, root); } } } @@ -189,7 +189,7 @@ static void db_rebalance (struct dbn *p, struct dbn **root) } // param z = node to remove -static void db_rebalance_erase (struct dbn *z, struct dbn **root) +static void db_rebalance_erase(struct dbn *z, struct dbn **root) { struct dbn *y = z; struct dbn *x = NULL; @@ -257,7 +257,7 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root) { w->color = BLACK; x_parent->color = RED; - db_rotate_left (x_parent, root); + db_rotate_left(x_parent, root); w = x_parent->right; } if ((!w->left || w->left->color == BLACK) && @@ -274,14 +274,14 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root) if (w->left) w->left->color = BLACK; w->color = RED; - db_rotate_right (w, root); + db_rotate_right(w, root); w = x_parent->right; } w->color = x_parent->color; x_parent->color = BLACK; if (w->right) w->right->color = BLACK; - db_rotate_left (x_parent, root); + db_rotate_left(x_parent, root); break; } } @@ -293,7 +293,7 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root) { w->color = BLACK; x_parent->color = RED; - db_rotate_right (x_parent, root); + db_rotate_right(x_parent, root); w = x_parent->left; } if ((!w->right || w->right->color == BLACK) && @@ -310,14 +310,14 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root) if (w->right) w->right->color = BLACK; w->color = RED; - db_rotate_left (w, root); + db_rotate_left(w, root); w = x_parent->left; } w->color = x_parent->color; x_parent->color = BLACK; if (w->left) w->left->color = BLACK; - db_rotate_right (x_parent, root); + db_rotate_right(x_parent, root); break; } } @@ -326,21 +326,21 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root) } } -struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data) +struct dbn *db_insert(struct dbt *table, db_key_t key, db_val_t data) { - hash_t hash = table_hash (table, key) % HASH_SIZE; + hash_t hash = table_hash(table, key) % HASH_SIZE; int c = 0; struct dbn *prev = NULL; struct dbn *p = table->ht[hash]; while (p) { - c = table_cmp (table, key, p->key); + c = table_cmp(table, key, p->key); if (c == 0) { // key found in table, replace // Tell the user of the table to free the key and value if (table->release) - table->release (p->key, p->data); + table->release(p->key, p->data); p->data = data; p->key = key; return p; @@ -352,7 +352,7 @@ struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data) else p = p->right; } - CREATE (p, struct dbn, 1); + CREATE(p, struct dbn, 1); p->key = key; p->data = data; p->color = RED; @@ -370,18 +370,18 @@ struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data) if (prev->color == RED) { // must rebalance - db_rebalance (p, &table->ht[hash]); + db_rebalance(p, &table->ht[hash]); } return p; } -db_val_t db_erase (struct dbt *table, db_key_t key) +db_val_t db_erase(struct dbt *table, db_key_t key) { - hash_t hash = table_hash (table, key) % HASH_SIZE; + hash_t hash = table_hash(table, key) % HASH_SIZE; struct dbn *p = table->ht[hash]; while (p) { - int c = table_cmp (table, key, p->key); + int c = table_cmp(table, key, p->key); if (c == 0) break; if (c < 0) @@ -392,12 +392,12 @@ db_val_t db_erase (struct dbt *table, db_key_t key) if (!p) return NULL; db_val_t data = p->data; - db_rebalance_erase (p, &table->ht[hash]); - free (p); + db_rebalance_erase(p, &table->ht[hash]); + free(p); return data; } #ifdef SMART_WALK_TREE -static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va_list ap) +static inline void db_walk_tree(bool dealloc, struct dbn* p, db_func_t func, va_list ap) { if (!p) return; @@ -415,7 +415,7 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va { // apply_func loop if (func) - func (p->key, p->data, ap); + func(p->key, p->data, ap); if (p->left) { // continue descending @@ -434,7 +434,7 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va if (!p->parent) { if (dealloc) - free (p); + free(p); // if we have already done both children, there is no more to do return; } @@ -443,7 +443,7 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va // finished the left tree, now walk the right tree p = p->parent->right; if (dealloc) - free (p->parent->left); + free(p->parent->left); break; //goto apply_func; } // p->parent->right == p @@ -451,21 +451,21 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va // keep backtracking p = p->parent; if (dealloc) - free (p->right?:p->left); + free(p->right?:p->left); } //backtrack loop } // apply_func loop } #endif // SMART_WALK_TREE -void db_foreach (struct dbt *table, db_func_t func, ...) +void db_foreach(struct dbt *table, db_func_t func, ...) { va_list ap; - va_start (ap, func); + va_start(ap, func); for (int i = 0; i < HASH_SIZE; i++) { #ifdef SMART_WALK_TREE - db_walk_tree (false, table->ht[i], func, ap); + db_walk_tree(false, table->ht[i], func, ap); #else struct dbn *p = table->ht[i]; if (!p) @@ -474,7 +474,7 @@ void db_foreach (struct dbt *table, db_func_t func, ...) int sp = 0; while (1) { - func (p->key, p->data, ap); + func(p->key, p->data, ap); struct dbn *pn = p->left; if (pn) { @@ -496,19 +496,19 @@ void db_foreach (struct dbt *table, db_func_t func, ...) } // while true #endif // else ! SMART_WALK_TREE } // for i - va_end (ap); + va_end(ap); } // This function is suspiciously similar to the previous -void db_final (struct dbt *table, db_func_t func, ...) +void db_final(struct dbt *table, db_func_t func, ...) { va_list ap; - va_start (ap, func); + va_start(ap, func); for (int i = 0; i < HASH_SIZE; i++) { #ifdef SMART_WALK_TREE - db_walk_tree (true, table->ht[i], func, ap); + db_walk_tree(true, table->ht[i], func, ap); #else struct dbn *p = table->ht[i]; if (!p) @@ -518,7 +518,7 @@ void db_final (struct dbt *table, db_func_t func, ...) while (1) { if (func) - func (p->key, p->data, ap); + func(p->key, p->data, ap); struct dbn *pn = p->left; if (pn) { @@ -536,11 +536,11 @@ void db_final (struct dbt *table, db_func_t func, ...) pn = stack[--sp]; } } // if pn else if !pn - free (p); + free(p); p = pn; } // while true #endif // else ! SMART_WALK_TREE } // for i - free (table); - va_end (ap); + free(table); + va_end(ap); } diff --git a/src/common/db.hpp b/src/common/db.hpp index 62125d8..313ba3a 100644 --- a/src/common/db.hpp +++ b/src/common/db.hpp @@ -28,7 +28,7 @@ typedef union db_key_t } db_key_t; typedef void* db_val_t; typedef uint32_t hash_t; -typedef void (*db_func_t)(db_key_t, db_val_t, va_list); +typedef void(*db_func_t)(db_key_t, db_val_t, va_list); /// DataBase Node struct dbn @@ -51,40 +51,40 @@ struct dbt dbt_type type; /// Note, before replacement, key/values to be replaced // TODO refactor to decrease/eliminate the uses of this? - void (*release) (db_key_t, db_val_t) __attribute__((deprecated)); + void(*release)(db_key_t, db_val_t) __attribute__((deprecated)); /// Maximum length of a string key - TODO refactor to ensure all strings are NUL-terminated size_t maxlen __attribute__((deprecated)); /// The root trees struct dbn *ht[HASH_SIZE]; }; -# define strdb_search(t,k) db_search((t),(db_key_t)(k)) -# define strdb_insert(t,k,d) db_insert((t),(db_key_t)(k),(db_val_t)(d)) -# define strdb_erase(t,k) db_erase ((t),(db_key_t)(k)) +# define strdb_search(t,k) db_search((t), (db_key_t)(k)) +# define strdb_insert(t,k,d) db_insert((t), (db_key_t)(k), (db_val_t)(d)) +# define strdb_erase(t,k) db_erase((t), (db_key_t)(k)) # define strdb_foreach db_foreach # define strdb_final db_final -# define numdb_search(t,k) db_search((t),(db_key_t)(k)) -# define numdb_insert(t,k,d) db_insert((t),(db_key_t)(k),(db_val_t)(d)) -# define numdb_erase(t,k) db_erase ((t),(db_key_t)(k)) +# define numdb_search(t,k) db_search((t), (db_key_t)(k)) +# define numdb_insert(t,k,d) db_insert((t), (db_key_t)(k), (db_val_t)(d)) +# define numdb_erase(t,k) db_erase((t), (db_key_t)(k)) # define numdb_foreach db_foreach # define numdb_final db_final /// Create a map from char* to void*, with strings possibly not null-terminated -struct dbt *strdb_init (size_t maxlen); +struct dbt *strdb_init(size_t maxlen); /// Create a map from int to void* -struct dbt *numdb_init (void); +struct dbt *numdb_init(void); /// Return the value corresponding to the key, or NULL if not found -db_val_t db_search (struct dbt *table, db_key_t key); +db_val_t db_search(struct dbt *table, db_key_t key); /// Add or replace table[key] = data // if it was already there, call release -struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data); +struct dbn *db_insert(struct dbt *table, db_key_t key, db_val_t data); /// Remove a key from the table, returning the data -db_val_t db_erase (struct dbt *table, db_key_t key); +db_val_t db_erase(struct dbt *table, db_key_t key); /// Execute a function for every element, in unspecified order -void db_foreach (struct dbt *, db_func_t, ...); +void db_foreach(struct dbt *, db_func_t, ...); // opposite of init? Calls release for every element and frees memory // This probably isn't really needed: we don't have to free memory while exiting -void db_final (struct dbt *, db_func_t, ...) __attribute__((deprecated)); +void db_final(struct dbt *, db_func_t, ...) __attribute__((deprecated)); #endif diff --git a/src/common/grfio.cpp b/src/common/grfio.cpp index dd1e707..042de85 100644 --- a/src/common/grfio.cpp +++ b/src/common/grfio.cpp @@ -34,7 +34,7 @@ static int16_t filelist_hash[256] = {l,l,l,l,l,l,l,l,l,l,l,l,l,l,l,l}; #undef l /// Hash a filename -static uint8_t filehash (const char *fname) +static uint8_t filehash(const char *fname) { // Larger than the return type - upper bits are used in the process uint32_t hash = 0; @@ -48,12 +48,12 @@ static uint8_t filehash (const char *fname) /// Find the filelist entry for the given filename, or NULL if it is not static -FILELIST *filelist_find (const char *fname) +FILELIST *filelist_find(const char *fname) { - int16_t index = filelist_hash[filehash (fname)]; + int16_t index = filelist_hash[filehash(fname)]; while (index >= 0) { - if (strcmp (filelist[index].fn, fname) == 0) + if (strcmp(filelist[index].fn, fname) == 0) return &filelist[index]; index = filelist[index].next; } @@ -61,24 +61,24 @@ FILELIST *filelist_find (const char *fname) } /// Copy a temporary entry into the hash map -static FILELIST *filelist_add (FILELIST * entry) +static FILELIST *filelist_add(FILELIST * entry) { if (filelist_entrys >= FILELIST_LIMIT) { - fprintf (stderr, "filelist limit : filelist_add\n"); - exit (1); + fprintf(stderr, "filelist limit : filelist_add\n"); + exit(1); } if (filelist_entrys >= filelist_maxentry) { RECREATE(filelist, FILELIST, filelist_maxentry + FILELIST_ADDS); - memset (filelist + filelist_maxentry, '\0', - FILELIST_ADDS * sizeof (FILELIST)); + memset(filelist + filelist_maxentry, '\0', + FILELIST_ADDS * sizeof(FILELIST)); filelist_maxentry += FILELIST_ADDS; } uint16_t new_index = filelist_entrys++; - uint8_t hash = filehash (entry->fn); + uint8_t hash = filehash(entry->fn); entry->next = filelist_hash[hash]; filelist_hash[hash] = new_index; @@ -87,26 +87,26 @@ static FILELIST *filelist_add (FILELIST * entry) return &filelist[new_index]; } -static FILELIST *filelist_modify (FILELIST * entry) +static FILELIST *filelist_modify(FILELIST * entry) { - FILELIST *fentry = filelist_find (entry->fn); + FILELIST *fentry = filelist_find(entry->fn); if (fentry) { entry->next = fentry->next; *fentry = *entry; return fentry; } - return filelist_add (entry); + return filelist_add(entry); } /// Change fname data/*.gat to lfname data/*.wlk // TODO even if the file exists, don't keep reopening it every time one loads static -void grfio_resnametable (const char *fname, char *lfname) +void grfio_resnametable(const char *fname, char *lfname) { char restable[] = "data/resnametable.txt"; - FILE *fp = fopen_ (restable, "rb"); + FILE *fp = fopen_(restable, "rb"); if (fp == NULL) { fprintf(stderr, "No resnametable, can't look for %s\n", fname); @@ -118,23 +118,23 @@ void grfio_resnametable (const char *fname, char *lfname) } char line[512]; - while (fgets (line, sizeof (line), fp)) + while (fgets(line, sizeof(line), fp)) { char w1[256], w2[256]; if ( // line is of the form foo.gat#foo.wlk# - (sscanf (line, "%[^#]#%[^#]#", w1, w2) == 2) + (sscanf(line, "%[^#]#%[^#]#", w1, w2) == 2) // strip data/ from foo.gat before comparing - && (!strcmp (w1, fname + 5))) + && (!strcmp(w1, fname + 5))) { - strcpy (lfname, "data/"); - strcpy (lfname + 5, w2); - fclose_ (fp); + strcpy(lfname, "data/"); + strcpy(lfname + 5, w2); + fclose_(fp); return; } } fprintf(stderr, "Unable to find resource: %s\n", fname); - fclose_ (fp); + fclose_(fp); strcpy(lfname, fname); char* ext = lfname + strlen(lfname) - 4; @@ -144,9 +144,9 @@ void grfio_resnametable (const char *fname, char *lfname) } /// Size of resource -size_t grfio_size (const char *fname) +size_t grfio_size(const char *fname) { - FILELIST *entry = filelist_find (fname); + FILELIST *entry = filelist_find(fname); if (entry) return entry->declen; @@ -154,60 +154,60 @@ size_t grfio_size (const char *fname) FILELIST lentry; struct stat st; - grfio_resnametable (fname, lfname); + grfio_resnametable(fname, lfname); for (char *p = lfname; *p; p++) if (*p == '\\') *p = '/'; - if (stat (lfname, &st) == 0) + if (stat(lfname, &st) == 0) { - strncpy (lentry.fn, fname, sizeof (lentry.fn) - 1); + strncpy(lentry.fn, fname, sizeof(lentry.fn) - 1); lentry.declen = st.st_size; - entry = filelist_modify (&lentry); + entry = filelist_modify(&lentry); } else { - printf ("%s not found\n", fname); + printf("%s not found\n", fname); return 0; } return entry->declen; } -void *grfio_reads (const char *fname, size_t *size) +void *grfio_reads(const char *fname, size_t *size) { char lfname[256]; - grfio_resnametable (fname, lfname); + grfio_resnametable(fname, lfname); for (char *p = &lfname[0]; *p != 0; p++) if (*p == '\\') *p = '/'; // * At the time of Unix - FILE *in = fopen_ (lfname, "rb"); + FILE *in = fopen_(lfname, "rb"); if (!in) { - fprintf (stderr, "%s not found\n", fname); + fprintf(stderr, "%s not found\n", fname); return NULL; } FILELIST lentry; - FILELIST *entry = filelist_find (fname); + FILELIST *entry = filelist_find(fname); if (entry) { lentry.declen = entry->declen; } else { - fseek (in, 0, SEEK_END); - lentry.declen = ftell (in); - fseek (in, 0, SEEK_SET); - strncpy (lentry.fn, fname, sizeof (lentry.fn) - 1); - entry = filelist_modify (&lentry); + fseek(in, 0, SEEK_END); + lentry.declen = ftell(in); + fseek(in, 0, SEEK_SET); + strncpy(lentry.fn, fname, sizeof(lentry.fn) - 1); + entry = filelist_modify(&lentry); } uint8_t *buf2; - CREATE (buf2, uint8_t, lentry.declen + 1024); - if (fread (buf2, 1, lentry.declen, in) != lentry.declen) + CREATE(buf2, uint8_t, lentry.declen + 1024); + if (fread(buf2, 1, lentry.declen, in) != lentry.declen) exit(1); - fclose_ (in); + fclose_(in); in = NULL; if (size) diff --git a/src/common/grfio.hpp b/src/common/grfio.hpp index 3485904..f418ac3 100644 --- a/src/common/grfio.hpp +++ b/src/common/grfio.hpp @@ -6,12 +6,12 @@ #define GRFIO_HPP /// Load file into memory -# define grfio_read(resourcename) grfio_reads (resourcename, NULL) +# define grfio_read(resourcename) grfio_reads(resourcename, NULL) /// Load file into memory and possibly record length // For some reason, this allocates an extra 1024 bytes at the end -void *grfio_reads (const char *resourcename, size_t *size); +void *grfio_reads(const char *resourcename, size_t *size); /// Get size of file // This is only called once, and that is to check the existence of a file. -size_t grfio_size (const char *resourcename) __attribute__((deprecated)); +size_t grfio_size(const char *resourcename) __attribute__((deprecated)); #endif // GRFIO_HPP diff --git a/src/common/lock.cpp b/src/common/lock.cpp index 2ba9a0a..13a99c5 100644 --- a/src/common/lock.cpp +++ b/src/common/lock.cpp @@ -7,30 +7,30 @@ /// (Until the file is closed, it keeps the old file) // Start writing a tmpfile -FILE *lock_fopen (const char *filename, int *info) +FILE *lock_fopen(const char *filename, int *info) { char newfile[512]; FILE *fp; - int no = getpid (); + int no = getpid(); // Get a filename that doesn't already exist do { - sprintf (newfile, "%s_%d.tmp", filename, no++); + sprintf(newfile, "%s_%d.tmp", filename, no++); } - while ((fp = fopen_ (newfile, "r")) && (fclose_ (fp), 1)); + while ((fp = fopen_(newfile, "r")) && (fclose_(fp), 1)); *info = --no; - return fopen_ (newfile, "w"); + return fopen_(newfile, "w"); } // Delete the old file and rename the new file -void lock_fclose (FILE * fp, const char *filename, int *info) +void lock_fclose(FILE * fp, const char *filename, int *info) { char newfile[512]; if (fp) { - fclose_ (fp); - sprintf (newfile, "%s_%d.tmp", filename, *info); - rename (newfile, filename); + fclose_(fp); + sprintf(newfile, "%s_%d.tmp", filename, *info); + rename(newfile, filename); } } diff --git a/src/common/lock.hpp b/src/common/lock.hpp index 19c1302..d6128d8 100644 --- a/src/common/lock.hpp +++ b/src/common/lock.hpp @@ -2,7 +2,7 @@ #define LOCK_HPP /// Locked FILE I/O // Changes are made in a separate file until lock_fclose -FILE *lock_fopen (const char *filename, int *info); -void lock_fclose (FILE * fp, const char *filename, int *info); +FILE *lock_fopen(const char *filename, int *info); +void lock_fclose(FILE * fp, const char *filename, int *info); #endif // LOCK_HPP diff --git a/src/common/md5calc.cpp b/src/common/md5calc.cpp index b0f8e5f..9027bc9 100644 --- a/src/common/md5calc.cpp +++ b/src/common/md5calc.cpp @@ -193,7 +193,7 @@ MD5_state MD5_from_string(const char* msg, const size_t msglen) } // now pad 1-512 bits + the 64-bit length - may be two blocks uint8_t buf[0x40] = {}; - memcpy (buf, msg, rem); + memcpy(buf, msg, rem); buf[rem] = 0x80; // a single one bit if (64 - rem > 8) { diff --git a/src/common/md5calc.hpp b/src/common/md5calc.hpp index 2dfaecb..2aed0bc 100644 --- a/src/common/md5calc.hpp +++ b/src/common/md5calc.hpp @@ -37,13 +37,13 @@ MD5_state MD5_from_FILE(FILE* in); /// Output in ASCII - with lowercase hex digits, null-terminated // these may overlap safely -static void MD5_String (const char *string, char output[33]) __attribute__((deprecated)); -static inline void MD5_String (const char *string, char output[33]) { +static void MD5_String(const char *string, char output[33]) __attribute__((deprecated)); +static inline void MD5_String(const char *string, char output[33]) { MD5_to_str(MD5_from_cstring(string), output); } /// Output in binary -static void MD5_String2binary (const char *string, uint8_t output[16]) __attribute__((deprecated)); -static inline void MD5_String2binary (const char *string, uint8_t output[16]) { +static void MD5_String2binary(const char *string, uint8_t output[16]) __attribute__((deprecated)); +static inline void MD5_String2binary(const char *string, uint8_t output[16]) { MD5_to_bin(MD5_from_cstring(string), output); } diff --git a/src/common/mmo.hpp b/src/common/mmo.hpp index 45f86cf..7441a16 100644 --- a/src/common/mmo.hpp +++ b/src/common/mmo.hpp @@ -51,7 +51,7 @@ struct item { - int id; + int id; short nameid; short amount; unsigned short equip; @@ -76,23 +76,23 @@ struct skill struct global_reg { char str[32]; - int value; + int value; }; struct mmo_charstatus { - int char_id; - int account_id; - int partner_id; + int char_id; + int account_id; + int partner_id; - int base_exp, job_exp, zeny; + int base_exp, job_exp, zeny; short pc_class; short status_point, skill_point; - int hp, max_hp, sp, max_sp; + int hp, max_hp, sp, max_sp; short option, karma, manner; short hair, hair_color, clothes_color; - int party_id; + int party_id; short weapon, shield; short head_top, head_mid, head_bottom; @@ -108,18 +108,18 @@ struct mmo_charstatus struct point last_point, save_point, memo_point[10]; struct item inventory[MAX_INVENTORY], cart[MAX_CART]; struct skill skill[MAX_SKILL]; - int global_reg_num; + int global_reg_num; struct global_reg global_reg[GLOBAL_REG_NUM]; - int account_reg_num; + int account_reg_num; struct global_reg account_reg[ACCOUNT_REG_NUM]; - int account_reg2_num; + int account_reg2_num; struct global_reg account_reg2[ACCOUNT_REG2_NUM]; }; struct storage { - int dirty; - int account_id; + int dirty; + int account_id; short storage_status; short storage_amount; struct item storage_[MAX_STORAGE]; @@ -129,31 +129,31 @@ struct map_session_data; struct gm_account { - int account_id; - int level; + int account_id; + int level; }; struct party_member { - int account_id; + int account_id; char name[24], map[24]; - int leader, online, lv; + int leader, online, lv; struct map_session_data *sd; }; struct party { - int party_id; + int party_id; char name[24]; - int exp; - int item; + int exp; + int item; struct party_member member[MAX_PARTY]; }; struct square { - int val1[5]; - int val2[5]; + int val1[5]; + int val2[5]; }; #endif // MMO_HPP diff --git a/src/common/mt_rand.cpp b/src/common/mt_rand.cpp index 676eca1..91ae2e4 100644 --- a/src/common/mt_rand.cpp +++ b/src/common/mt_rand.cpp @@ -61,7 +61,7 @@ static uint32_t state[N+1]; // state vector the +1 is needed due to the coding static uint32_t *next; // next random value is computed from here static int left = -1; // can *next++ this many times before reloading -void mt_seed (uint32_t seed) +void mt_seed(uint32_t seed) { uint32_t x = seed | 1U; uint32_t *s = state; @@ -71,11 +71,11 @@ void mt_seed (uint32_t seed) } static -void mt_reload (void) +void mt_reload(void) { // if mt_seed has never been called if (left < -1) - mt_seed (time (NULL)); + mt_seed(time(NULL)); // conceptually, these are indices into the state that wrap uint32_t *p0 = state; @@ -87,27 +87,27 @@ void mt_reload (void) // regenerate the lower N-M elements of the state for (int j = N-M+1; --j != 0; s0 = s1, s1 = *p2++) - *p0++ = *pM++ ^ (mixBits (s0, s1) >> 1) ^ (loBit (s1) ? K : 0U); + *p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U); pM = state; // regenerate the next M-1 elements of the state // note that s1 is set to state[N] at the end, but discarded for (int j = M; --j != 0; s0 = s1, s1 = *p2++) - *p0++ = *pM++ ^ (mixBits (s0, s1) >> 1) ^ (loBit (s1) ? K : 0U); + *p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U); // regenerate the last 1 element of the state s1 = state[0]; - *p0 = *pM ^ (mixBits (s0, s1) >> 1) ^ (loBit (s1) ? K : 0U); + *p0 = *pM ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U); // ready for the normal mt_random algorithm left = N; next = state; } -uint32_t mt_random (void) +uint32_t mt_random(void) { if (--left < 0) - mt_reload (); + mt_reload(); uint32_t y = *next++; y ^= (y >> 11); diff --git a/src/common/mt_rand.hpp b/src/common/mt_rand.hpp index c7bae4e..ae5986b 100644 --- a/src/common/mt_rand.hpp +++ b/src/common/mt_rand.hpp @@ -4,9 +4,9 @@ # include "sanity.hpp" /// Initialize the generator (called automatically with time() if you don't) -void mt_seed (uint32_t seed); +void mt_seed(uint32_t seed); /// Get a random number -uint32_t mt_random (void); +uint32_t mt_random(void); /** * ModuloRand and ModuloPlusRand diff --git a/src/common/nullpo.cpp b/src/common/nullpo.cpp index 67c839f..ad52009 100644 --- a/src/common/nullpo.cpp +++ b/src/common/nullpo.cpp @@ -3,13 +3,13 @@ #include #include "nullpo.hpp" -static void nullpo_info_core (const char *file, int line, const char *func); +static void nullpo_info_core(const char *file, int line, const char *func); __attribute__((format(printf, 4, 0))) -static void nullpo_info_core (const char *file, int line, const char *func, +static void nullpo_info_core(const char *file, int line, const char *func, const char *fmt, va_list ap); /// Null check and print format -bool nullpo_chk_f (const char *file, int line, const char *func, +bool nullpo_chk_f(const char *file, int line, const char *func, const void *target, const char *fmt, ...) { va_list ap; @@ -17,55 +17,55 @@ bool nullpo_chk_f (const char *file, int line, const char *func, if (target) return 0; - va_start (ap, fmt); - nullpo_info_core (file, line, func, fmt, ap); - va_end (ap); + va_start(ap, fmt); + nullpo_info_core(file, line, func, fmt, ap); + va_end(ap); return 1; } -bool nullpo_chk (const char *file, int line, const char *func, +bool nullpo_chk(const char *file, int line, const char *func, const void *target) { if (target) return 0; - nullpo_info_core (file, line, func); + nullpo_info_core(file, line, func); return 1; } /// External functions -void nullpo_info_f (const char *file, int line, const char *func, +void nullpo_info_f(const char *file, int line, const char *func, const char *fmt, ...) { va_list ap; - va_start (ap, fmt); - nullpo_info_core (file, line, func, fmt, ap); - va_end (ap); + va_start(ap, fmt); + nullpo_info_core(file, line, func, fmt, ap); + va_end(ap); } -void nullpo_info (const char *file, int line, const char *func) +void nullpo_info(const char *file, int line, const char *func) { - nullpo_info_core (file, line, func); + nullpo_info_core(file, line, func); } /// Actual output function -static void nullpo_info_core (const char *file, int line, const char *func) +static void nullpo_info_core(const char *file, int line, const char *func) { if (!file) file = "??"; if (!func || !*func) func = "unknown"; - fprintf (stderr, "%s:%d: in func `%s': NULL pointer\n", file, line, func); + fprintf(stderr, "%s:%d: in func `%s': NULL pointer\n", file, line, func); } -static void nullpo_info_core (const char *file, int line, const char *func, +static void nullpo_info_core(const char *file, int line, const char *func, const char *fmt, va_list ap) { nullpo_info_core(file, line, func); if (fmt && *fmt) { - vfprintf (stderr, fmt, ap); - if (fmt[strlen (fmt) - 1] != '\n') + vfprintf(stderr, fmt, ap); + if (fmt[strlen(fmt) - 1] != '\n') fputc('\n', stderr); } } diff --git a/src/common/nullpo.hpp b/src/common/nullpo.hpp index 7aff691..25ab2b9 100644 --- a/src/common/nullpo.hpp +++ b/src/common/nullpo.hpp @@ -42,20 +42,20 @@ # include "sanity.hpp" /// Used by macros in this header -bool nullpo_chk (const char *file, int line, const char *func, +bool nullpo_chk(const char *file, int line, const char *func, const void *target); /// Used by macros in this header -bool nullpo_chk_f (const char *file, int line, const char *func, +bool nullpo_chk_f(const char *file, int line, const char *func, const void *target, const char *fmt, ...) - __attribute__ ((format (printf, 5, 6))); + __attribute__((format(printf, 5, 6))); /// Used only by map/battle.c -void nullpo_info (const char *file, int line, const char *func); +void nullpo_info(const char *file, int line, const char *func); /// Not used -void nullpo_info_f (const char *file, int line, const char *func, +void nullpo_info_f(const char *file, int line, const char *func, const char *fmt, ...) - __attribute__ ((format (printf, 4, 5))); + __attribute__((format(printf, 4, 5))); #endif // NULLPO_HPP diff --git a/src/common/socket.cpp b/src/common/socket.cpp index cc6e4b3..fb254dc 100644 --- a/src/common/socket.cpp +++ b/src/common/socket.cpp @@ -20,8 +20,8 @@ #include "utils.hpp" fd_set readfds; -int fd_max; -int currentuse; +int fd_max; +int currentuse; const uint32_t RFIFO_SIZE = 65536; const uint32_t WFIFO_SIZE = 65536; @@ -29,23 +29,23 @@ const uint32_t WFIFO_SIZE = 65536; struct socket_data *session[FD_SETSIZE]; /// Discard all input -static void null_parse (int fd); +static void null_parse(int fd); /// Default parser for new connections -static void (*default_func_parse) (int) = null_parse; +static void(*default_func_parse)(int) = null_parse; -void set_defaultparse (void (*defaultparse) (int)) +void set_defaultparse(void(*defaultparse)(int)) { default_func_parse = defaultparse; } /// Read from socket to the queue -static void recv_to_fifo (int fd) +static void recv_to_fifo(int fd) { if (session[fd]->eof) return; - ssize_t len = read (fd, session[fd]->rdata + session[fd]->rdata_size, - RFIFOSPACE (fd)); + ssize_t len = read(fd, session[fd]->rdata + session[fd]->rdata_size, + RFIFOSPACE(fd)); if (len > 0) { @@ -58,19 +58,19 @@ static void recv_to_fifo (int fd) } } -static void send_from_fifo (int fd) +static void send_from_fifo(int fd) { if (session[fd]->eof) return; - ssize_t len = write (fd, session[fd]->wdata, session[fd]->wdata_size); + ssize_t len = write(fd, session[fd]->wdata, session[fd]->wdata_size); if (len > 0) { session[fd]->wdata_size -= len; if (len < (ssize_t)session[fd]->wdata_size) { - memmove (session[fd]->wdata, session[fd]->wdata + len, + memmove(session[fd]->wdata, session[fd]->wdata + len, session[fd]->wdata_size); } session[fd]->connected = 1; @@ -81,32 +81,32 @@ static void send_from_fifo (int fd) } } -static void null_parse (int fd) +static void null_parse(int fd) { - printf ("null_parse : %d\n", fd); - RFIFOSKIP (fd, RFIFOREST (fd)); + printf("null_parse : %d\n", fd); + RFIFOSKIP(fd, RFIFOREST(fd)); } -static void connect_client (int listen_fd) +static void connect_client(int listen_fd) { struct sockaddr_in client_address; - socklen_t len = sizeof (client_address); + socklen_t len = sizeof(client_address); - int fd = accept (listen_fd, (struct sockaddr *) &client_address, &len); + int fd = accept(listen_fd, (struct sockaddr *) &client_address, &len); if (fd == -1) { - perror ("accept"); + perror("accept"); return; } if (fd_max <= fd) { fd_max = fd + 1; } - if (!free_fds ()) + if (!free_fds()) { - fprintf (stderr, "softlimit reached, disconnecting : %d\n", fd); - delete_session (fd); + fprintf(stderr, "softlimit reached, disconnecting : %d\n", fd); + delete_session(fd); return; } @@ -114,20 +114,20 @@ static void connect_client (int listen_fd) /// Allow to bind() again after the server restarts. // Since the socket is still in the TIME_WAIT, there's a possibility // that formerly lost packets might be delivered and confuse the server. - setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); + setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); /// Send packets as soon as possible /// even if the kernel thinks there is too little for it to be worth it! // I'm not convinced this is a good idea; although in minimizes the // latency for an individual write, it increases traffic in general. - setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes); + setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes); - FD_SET (fd, &readfds); + FD_SET(fd, &readfds); - fcntl (fd, F_SETFL, O_NONBLOCK); + fcntl(fd, F_SETFL, O_NONBLOCK); - CREATE (session[fd], struct socket_data, 1); - CREATE (session[fd]->rdata, uint8_t, RFIFO_SIZE); - CREATE (session[fd]->wdata, uint8_t, WFIFO_SIZE); + CREATE(session[fd], struct socket_data, 1); + CREATE(session[fd]->rdata, uint8_t, RFIFO_SIZE); + CREATE(session[fd]->wdata, uint8_t, WFIFO_SIZE); session[fd]->max_rdata = RFIFO_SIZE; session[fd]->max_wdata = WFIFO_SIZE; @@ -135,72 +135,72 @@ static void connect_client (int listen_fd) session[fd]->func_send = send_from_fifo; session[fd]->func_parse = default_func_parse; session[fd]->client_addr = client_address; - session[fd]->created = time (NULL); + session[fd]->created = time(NULL); session[fd]->connected = 0; currentuse++; } -int make_listen_port (uint16_t port) +int make_listen_port(uint16_t port) { struct sockaddr_in server_address; - int fd = socket (AF_INET, SOCK_STREAM, 0); + int fd = socket(AF_INET, SOCK_STREAM, 0); if (fd == -1) { - perror ("socket"); + perror("socket"); return -1; } if (fd_max <= fd) fd_max = fd + 1; - fcntl (fd, F_SETFL, O_NONBLOCK); + fcntl(fd, F_SETFL, O_NONBLOCK); const int yes = 1; /// Allow to bind() again after the server restarts. // Since the socket is still in the TIME_WAIT, there's a possibility // that formerly lost packets might be delivered and confuse the server. - setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); + setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); /// Send packets as soon as possible /// even if the kernel thinks there is too little for it to be worth it! // I'm not convinced this is a good idea; although in minimizes the // latency for an individual write, it increases traffic in general. - setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes); + setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes); server_address.sin_family = AF_INET; - server_address.sin_addr.s_addr = htonl (INADDR_ANY); - server_address.sin_port = htons (port); + server_address.sin_addr.s_addr = htonl(INADDR_ANY); + server_address.sin_port = htons(port); - if (bind (fd, (struct sockaddr *) &server_address, - sizeof (server_address)) == -1) + if (bind(fd, (struct sockaddr *) &server_address, + sizeof(server_address)) == -1) { - perror ("bind"); - exit (1); + perror("bind"); + exit(1); } - if (listen (fd, 5) == -1) + if (listen(fd, 5) == -1) { /* error */ - perror ("listen"); - exit (1); + perror("listen"); + exit(1); } - FD_SET (fd, &readfds); + FD_SET(fd, &readfds); - CREATE (session[fd], struct socket_data, 1); + CREATE(session[fd], struct socket_data, 1); session[fd]->func_recv = connect_client; - session[fd]->created = time (NULL); + session[fd]->created = time(NULL); session[fd]->connected = 1; currentuse++; return fd; } -int make_connection (uint32_t ip, uint16_t port) +int make_connection(uint32_t ip, uint16_t port) { struct sockaddr_in server_address; - int fd = socket (AF_INET, SOCK_STREAM, 0); + int fd = socket(AF_INET, SOCK_STREAM, 0); if (fd == -1) { - perror ("socket"); + perror("socket"); return -1; } if (fd_max <= fd) @@ -210,43 +210,43 @@ int make_connection (uint32_t ip, uint16_t port) /// Allow to bind() again after the server restarts. // Since the socket is still in the TIME_WAIT, there's a possibility // that formerly lost packets might be delivered and confuse the server. - setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); + setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); /// Send packets as soon as possible /// even if the kernel thinks there is too little for it to be worth it! // I'm not convinced this is a good idea; although in minimizes the // latency for an individual write, it increases traffic in general. - setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes); + setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = ip; - server_address.sin_port = htons (port); + server_address.sin_port = htons(port); - fcntl (fd, F_SETFL, O_NONBLOCK); + fcntl(fd, F_SETFL, O_NONBLOCK); /// Errors not caught - we must not block /// Let the main select() loop detect when we know the state - connect (fd, (struct sockaddr *) &server_address, - sizeof (struct sockaddr_in)); + connect(fd, (struct sockaddr *) &server_address, + sizeof(struct sockaddr_in)); - FD_SET (fd, &readfds); + FD_SET(fd, &readfds); - CREATE (session[fd], struct socket_data, 1); - CREATE (session[fd]->rdata, uint8_t, RFIFO_SIZE); - CREATE (session[fd]->wdata, uint8_t, WFIFO_SIZE); + CREATE(session[fd], struct socket_data, 1); + CREATE(session[fd]->rdata, uint8_t, RFIFO_SIZE); + CREATE(session[fd]->wdata, uint8_t, WFIFO_SIZE); session[fd]->max_rdata = RFIFO_SIZE; session[fd]->max_wdata = WFIFO_SIZE; session[fd]->func_recv = recv_to_fifo; session[fd]->func_send = send_from_fifo; session[fd]->func_parse = default_func_parse; - session[fd]->created = time (NULL); + session[fd]->created = time(NULL); session[fd]->connected = 1; currentuse++; return fd; } -void delete_session (int fd) +void delete_session(int fd) { if (fd < 0 || fd >= FD_SETSIZE) return; @@ -255,151 +255,151 @@ void delete_session (int fd) // but this is cheap and good enough for the typical case if (fd == fd_max - 1) fd_max--; - FD_CLR (fd, &readfds); + FD_CLR(fd, &readfds); if (session[fd]) { - free (session[fd]->rdata); - free (session[fd]->wdata); - free (session[fd]->session_data); - free (session[fd]); + free(session[fd]->rdata); + free(session[fd]->wdata); + free(session[fd]->session_data); + free(session[fd]); } session[fd] = NULL; // just close() would try to keep sending buffers - shutdown (fd, SHUT_RDWR); - close (fd); + shutdown(fd, SHUT_RDWR); + close(fd); currentuse--; if (currentuse < 0) { - fprintf (stderr, "delete_session: current sessions negative!\n"); + fprintf(stderr, "delete_session: current sessions negative!\n"); currentuse = 0; } return; } -void realloc_fifo (int fd, size_t rfifo_size, size_t wfifo_size) +void realloc_fifo(int fd, size_t rfifo_size, size_t wfifo_size) { struct socket_data *s = session[fd]; if (s->max_rdata != rfifo_size && s->rdata_size < rfifo_size) { - RECREATE (s->rdata, uint8_t, rfifo_size); + RECREATE(s->rdata, uint8_t, rfifo_size); s->max_rdata = rfifo_size; } if (s->max_wdata != wfifo_size && s->wdata_size < wfifo_size) { - RECREATE (s->wdata, uint8_t, wfifo_size); + RECREATE(s->wdata, uint8_t, wfifo_size); s->max_wdata = wfifo_size; } } -void WFIFOSET (int fd, size_t len) +void WFIFOSET(int fd, size_t len) { struct socket_data *s = session[fd]; if (s->wdata_size + len + 16384 > s->max_wdata) { - realloc_fifo (fd, s->max_rdata, s->max_wdata << 1); - printf ("socket: %d wdata expanded to %d bytes.\n", fd, s->max_wdata); + realloc_fifo(fd, s->max_rdata, s->max_wdata << 1); + printf("socket: %d wdata expanded to %d bytes.\n", fd, s->max_wdata); } if (s->wdata_size + len + 2048 < s->max_wdata) s->wdata_size += len; else - fprintf (stderr, "socket: %d wdata lost !!\n", fd), abort (); + fprintf(stderr, "socket: %d wdata lost !!\n", fd), abort(); } -void do_sendrecv (uint32_t next) +void do_sendrecv(uint32_t next) { fd_set rfd = readfds, wfd; - FD_ZERO (&wfd); + FD_ZERO(&wfd); for (int i = 0; i < fd_max; i++) { if (session[i] && session[i]->wdata_size) - FD_SET (i, &wfd); + FD_SET(i, &wfd); } struct timeval timeout; timeout.tv_sec = next / 1000; timeout.tv_usec = next % 1000 * 1000; - if (select (fd_max, &rfd, &wfd, NULL, &timeout) <= 0) + if (select(fd_max, &rfd, &wfd, NULL, &timeout) <= 0) return; for (int i = 0; i < fd_max; i++) { if (!session[i]) continue; - if (FD_ISSET (i, &wfd)) + if (FD_ISSET(i, &wfd)) { if (session[i]->func_send) //send_from_fifo(i); - session[i]->func_send (i); + session[i]->func_send(i); } - if (FD_ISSET (i, &rfd)) + if (FD_ISSET(i, &rfd)) { if (session[i]->func_recv) //recv_to_fifo(i); //or connect_client(i); - session[i]->func_recv (i); + session[i]->func_recv(i); } } } -void do_parsepacket (void) +void do_parsepacket(void) { for (int i = 0; i < fd_max; i++) { if (!session[i]) continue; if (!session[i]->connected - && time (NULL) - session[i]->created > CONNECT_TIMEOUT) + && time(NULL) - session[i]->created > CONNECT_TIMEOUT) { - printf ("Session #%d timed out\n", i); + printf("Session #%d timed out\n", i); session[i]->eof = 1; } if (!session[i]->rdata_size && !session[i]->eof) continue; if (session[i]->func_parse) { - session[i]->func_parse (i); + session[i]->func_parse(i); /// some func_parse may call delete_session if (!session[i]) continue; } /// Reclaim buffer space for what was read - RFIFOFLUSH (i); + RFIFOFLUSH(i); } } -void do_socket (void) +void do_socket(void) { - FD_ZERO (&readfds); + FD_ZERO(&readfds); currentuse = 3; } -void RFIFOSKIP (int fd, size_t len) +void RFIFOSKIP(int fd, size_t len) { struct socket_data *s = session[fd]; s->rdata_pos += len; if (s->rdata_size < s->rdata_pos) { - fprintf (stderr, "too many skip\n"); - abort (); + fprintf(stderr, "too many skip\n"); + abort(); } } -void fclose_ (FILE * fp) +void fclose_(FILE * fp) { - if (fclose (fp)) - perror ("fclose"), abort (); + if (fclose(fp)) + perror("fclose"), abort(); currentuse--; } -FILE *fopen_ (const char *path, const char *mode) +FILE *fopen_(const char *path, const char *mode) { - FILE *f = fopen (path, mode); + FILE *f = fopen(path, mode); if (f) currentuse++; return f; } -bool free_fds (void) +bool free_fds(void) { return currentuse < SOFT_LIMIT; } diff --git a/src/common/socket.hpp b/src/common/socket.hpp index 00f2df0..b2ef119 100644 --- a/src/common/socket.hpp +++ b/src/common/socket.hpp @@ -19,7 +19,7 @@ # define RFIFOW(fd,pos) (*(uint16_t*)(RFIFOP(fd, pos))) # define RFIFOL(fd,pos) (*(uint32_t*)(RFIFOP(fd, pos))) /// Done reading -void RFIFOSKIP (int fd, size_t len); +void RFIFOSKIP(int fd, size_t len); /// Internal - clean up by discarding handled bytes // Atm this is also called in char/char.c, but that is unnecessary # define RFIFOFLUSH(fd) (memmove(session[fd]->rdata,RFIFOP(fd,0),RFIFOREST(fd)),\ @@ -45,7 +45,7 @@ session[fd]->rdata_pos=0) # define WFIFOW(fd,pos) (*(uint16_t*)(WFIFOP(fd,pos))) # define WFIFOL(fd,pos) (*(uint32_t*)(WFIFOP(fd,pos))) /// Finish writing -void WFIFOSET (int fd, size_t len); +void WFIFOSET(int fd, size_t len); /// Write to an arbitrary buffer #define WBUFP(p,pos) (((uint8_t*)(p))+(pos)) @@ -80,13 +80,13 @@ struct socket_data /// Only called when select() indicates the socket is ready /// If, after that, nothing is read, it sets eof // These could probably be hard-coded with a little work - void (*func_recv) (int); - void (*func_send) (int); + void(*func_recv)(int); + void(*func_send)(int); /// This is the important one /// Set to different functions depending on whether the connection /// is a player or a server/ladmin /// Can be set explicitly or via set_defaultparse - void (*func_parse) (int); + void(*func_parse)(int); /// Server-specific data type void *session_data; }; @@ -106,30 +106,30 @@ extern int fd_max; /// open a socket, bind, and listen. Return an fd, or -1 if socket() fails, /// but exit if bind() or listen() fails -int make_listen_port (uint16_t port); +int make_listen_port(uint16_t port); /// Connect to an address, return a connected socket or -1 // FIXME - this is IPv4 only! -int make_connection (uint32_t ip, uint16_t port); +int make_connection(uint32_t ip, uint16_t port); /// free() the structure and close() the fd -void delete_session (int); +void delete_session(int); /// Make a the internal queues bigger -void realloc_fifo (int fd, size_t rfifo_size, size_t wfifo_size); +void realloc_fifo(int fd, size_t rfifo_size, size_t wfifo_size); /// Update all sockets that can be read/written from the queues -void do_sendrecv (uint32_t next); +void do_sendrecv(uint32_t next); /// Call the parser function for every socket that has read data -void do_parsepacket (void); +void do_parsepacket(void); /// An init function -void do_socket (void); +void do_socket(void); /// Change the default parser for newly connected clients // typically called once per server, but individual clients may identify // themselves as servers -void set_defaultparse (void (*defaultparse) (int)); +void set_defaultparse(void(*defaultparse)(int)); /// Wrappers to track number of free FDs -void fclose_ (FILE * fp); -FILE *fopen_ (const char *path, const char *mode); -bool free_fds (void); +void fclose_(FILE * fp); +FILE *fopen_(const char *path, const char *mode); +bool free_fds(void); #endif // SOCKET_HPP diff --git a/src/common/timer.cpp b/src/common/timer.cpp index 66aaa9b..8a12d19 100644 --- a/src/common/timer.cpp +++ b/src/common/timer.cpp @@ -29,30 +29,30 @@ static timer_id *timer_heap = NULL; static uint32_t gettick_cache; static uint8_t gettick_count = 0; -uint32_t gettick_nocache (void) +uint32_t gettick_nocache(void) { struct timeval tval; // BUG: This will cause strange behavior if the system clock is changed! // it should be reimplemented in terms of clock_gettime(CLOCK_MONOTONIC, ) - gettimeofday (&tval, NULL); + gettimeofday(&tval, NULL); gettick_count = 255; return gettick_cache = tval.tv_sec * 1000 + tval.tv_usec / 1000; } -uint32_t gettick (void) +uint32_t gettick(void) { if (gettick_count--) return gettick_cache; - return gettick_nocache (); + return gettick_nocache(); } -static void push_timer_heap (timer_id index) +static void push_timer_heap(timer_id index) { if (timer_heap == NULL || timer_heap[0] + 1 >= timer_heap_max) { timer_heap_max += 256; - RECREATE (timer_heap, timer_id, timer_heap_max); - memset (timer_heap + (timer_heap_max - 256), 0, sizeof (timer_id) * 256); + RECREATE(timer_heap, timer_id, timer_heap_max); + memset(timer_heap + (timer_heap_max - 256), 0, sizeof(timer_id) * 256); } // timer_heap[0] is the greatest index into the heap, which increases timer_heap[0]++; @@ -71,14 +71,14 @@ static void push_timer_heap (timer_id index) timer_heap[h + 1] = index; } -static timer_id top_timer_heap (void) +static timer_id top_timer_heap(void) { if (!timer_heap || !timer_heap[0]) return -1; return timer_heap[1]; } -static timer_id pop_timer_heap (void) +static timer_id pop_timer_heap(void) { if (!timer_heap || !timer_heap[0]) return -1; @@ -99,7 +99,7 @@ static timer_id pop_timer_heap (void) uint32_t i = (h - 1) / 2; while (h) { - if (DIFF_TICK (timer_data[timer_heap[i + 1]].tick, timer_data[last].tick) <= 0) + if (DIFF_TICK(timer_data[timer_heap[i + 1]].tick, timer_data[last].tick) <= 0) break; timer_heap[h + 1] = timer_heap[i + 1]; h = i; @@ -110,7 +110,7 @@ static timer_id pop_timer_heap (void) return ret; } -timer_id add_timer (tick_t tick, timer_func func, custom_id_t id, custom_data_t data) +timer_id add_timer(tick_t tick, timer_func func, custom_id_t id, custom_data_t data) { timer_id i; @@ -136,14 +136,14 @@ timer_id add_timer (tick_t tick, timer_func func, custom_id_t id, custom_data_t if (timer_data_max == 0) { timer_data_max = 256; - CREATE (timer_data, struct TimerData, timer_data_max); + CREATE(timer_data, struct TimerData, timer_data_max); } else { timer_data_max += 256; - RECREATE (timer_data, struct TimerData, timer_data_max); - memset (timer_data + (timer_data_max - 256), 0, - sizeof (struct TimerData) * 256); + RECREATE(timer_data, struct TimerData, timer_data_max); + memset(timer_data + (timer_data_max - 256), 0, + sizeof(struct TimerData) * 256); } } timer_data[i].tick = tick; @@ -152,32 +152,32 @@ timer_id add_timer (tick_t tick, timer_func func, custom_id_t id, custom_data_t timer_data[i].data = data; timer_data[i].type = TIMER_ONCE_AUTODEL; timer_data[i].interval = 1000; - push_timer_heap (i); + push_timer_heap(i); if (i >= timer_data_num) timer_data_num = i + 1; return i; } -timer_id add_timer_interval (tick_t tick, timer_func func, custom_id_t id, +timer_id add_timer_interval(tick_t tick, timer_func func, custom_id_t id, custom_data_t data, interval_t interval) { - timer_id tid = add_timer (tick, func, id, data); + timer_id tid = add_timer(tick, func, id, data); timer_data[tid].type = TIMER_INTERVAL; timer_data[tid].interval = interval; return tid; } -void delete_timer (timer_id id, timer_func func) +void delete_timer(timer_id id, timer_func func) { if (id == 0 || id >= timer_data_num) { - fprintf (stderr, "delete_timer error : no such timer %d\n", id); - abort (); + fprintf(stderr, "delete_timer error : no such timer %d\n", id); + abort(); } if (timer_data[id].func != func) { - fprintf (stderr, "Timer mismatch\n"); - abort (); + fprintf(stderr, "Timer mismatch\n"); + abort(); } // "to let them disappear" - is this just in case? timer_data[id].func = NULL; @@ -185,43 +185,43 @@ void delete_timer (timer_id id, timer_func func) timer_data[id].tick -= 60 * 60 * 1000; } -tick_t addtick_timer (timer_id tid, interval_t tick) +tick_t addtick_timer(timer_id tid, interval_t tick) { return timer_data[tid].tick += tick; } -struct TimerData *get_timer (timer_id tid) +struct TimerData *get_timer(timer_id tid) { return &timer_data[tid]; } -interval_t do_timer (tick_t tick) +interval_t do_timer(tick_t tick) { timer_id i; /// Number of milliseconds until it calls this again // this says to wait 1 sec if all timers get popped interval_t nextmin = 1000; - while ((i = top_timer_heap ()) != (timer_id)-1) + while ((i = top_timer_heap()) != (timer_id)-1) { // while the heap is not empty and - if (DIFF_TICK (timer_data[i].tick, tick) > 0) + if (DIFF_TICK(timer_data[i].tick, tick) > 0) { /// Return the time until the next timer needs to goes off - nextmin = DIFF_TICK (timer_data[i].tick, tick); + nextmin = DIFF_TICK(timer_data[i].tick, tick); break; } - pop_timer_heap (); + pop_timer_heap(); if (timer_data[i].func) { - if (DIFF_TICK (timer_data[i].tick, tick) < -1000) + if (DIFF_TICK(timer_data[i].tick, tick) < -1000) { // If we are too far past the requested tick, call with the current tick instead to fix reregistering problems - timer_data[i].func (i, tick, timer_data[i].id, timer_data[i].data); + timer_data[i].func(i, tick, timer_data[i].id, timer_data[i].data); } else { - timer_data[i].func (i, timer_data[i].tick, timer_data[i].id, timer_data[i].data); + timer_data[i].func(i, timer_data[i].tick, timer_data[i].id, timer_data[i].data); } } switch (timer_data[i].type) @@ -231,14 +231,14 @@ interval_t do_timer (tick_t tick) if (free_timer_list_pos >= free_timer_list_max) { free_timer_list_max += 256; - RECREATE (free_timer_list, uint32_t, free_timer_list_max); - memset (free_timer_list + (free_timer_list_max - 256), - 0, 256 * sizeof (uint32_t)); + RECREATE(free_timer_list, uint32_t, free_timer_list_max); + memset(free_timer_list + (free_timer_list_max - 256), + 0, 256 * sizeof(uint32_t)); } free_timer_list[free_timer_list_pos++] = i; break; case TIMER_INTERVAL: - if (DIFF_TICK (timer_data[i].tick, tick) < -1000) + if (DIFF_TICK(timer_data[i].tick, tick) < -1000) { timer_data[i].tick = tick + timer_data[i].interval; } @@ -246,7 +246,7 @@ interval_t do_timer (tick_t tick) { timer_data[i].tick += timer_data[i].interval; } - push_timer_heap (i); + push_timer_heap(i); break; } } diff --git a/src/common/timer.hpp b/src/common/timer.hpp index fdda344..fc4f8cb 100644 --- a/src/common/timer.hpp +++ b/src/common/timer.hpp @@ -19,7 +19,7 @@ typedef uint32_t timer_id; // BUG: pointers are stored in here typedef int32_t custom_id_t; typedef int32_t custom_data_t; -typedef void (*timer_func) (timer_id, tick_t, custom_id_t, custom_data_t); +typedef void(*timer_func)(timer_id, tick_t, custom_id_t, custom_data_t); struct TimerData { @@ -41,20 +41,20 @@ struct TimerData /// but use of 32-bit integers means it wraps every 49 days. // The only external caller of this function is the core.c main loop, but that makes sense // in fact, it might make more sense if gettick() ALWAYS returned that cached value -tick_t gettick_nocache (void); +tick_t gettick_nocache(void); /// This function is called enough that it's worth caching the result for /// the next 255 times -tick_t gettick (void); +tick_t gettick(void); -timer_id add_timer (tick_t, timer_func, custom_id_t, custom_data_t); -timer_id add_timer_interval (tick_t, timer_func, custom_id_t, custom_data_t, interval_t); -void delete_timer (timer_id, timer_func); +timer_id add_timer(tick_t, timer_func, custom_id_t, custom_data_t); +timer_id add_timer_interval(tick_t, timer_func, custom_id_t, custom_data_t, interval_t); +void delete_timer(timer_id, timer_func); -tick_t addtick_timer (timer_id, interval_t); -struct TimerData *get_timer (timer_id tid); +tick_t addtick_timer(timer_id, interval_t); +struct TimerData *get_timer(timer_id tid); /// Do all timers scheduled before tick, and return the number of milliseconds until the next timer happens -interval_t do_timer (tick_t tick); +interval_t do_timer(tick_t tick); diff --git a/src/common/utils.cpp b/src/common/utils.cpp index fbdd87e..732f3b1 100644 --- a/src/common/utils.cpp +++ b/src/common/utils.cpp @@ -9,10 +9,10 @@ //----------------------------------------------------- // Function to suppress control characters in a string. //----------------------------------------------------- -int remove_control_chars (char *str) +int remove_control_chars(char *str) { - int i; - int change = 0; + int i; + int change = 0; for (i = 0; str[i]; i++) { @@ -29,39 +29,39 @@ int remove_control_chars (char *str) //--------------------------------------------------- // E-mail check: return 0 (not correct) or 1 (valid). //--------------------------------------------------- -int e_mail_check (const char *email) +int e_mail_check(const char *email) { char ch; const char *last_arobas; // athena limits - if (strlen (email) < 3 || strlen (email) > 39) + if (strlen(email) < 3 || strlen(email) > 39) return 0; // part of RFC limits (official reference of e-mail description) - if (strchr (email, '@') == NULL || email[strlen (email) - 1] == '@') + if (strchr(email, '@') == NULL || email[strlen(email) - 1] == '@') return 0; - if (email[strlen (email) - 1] == '.') + if (email[strlen(email) - 1] == '.') return 0; - last_arobas = strrchr (email, '@'); + last_arobas = strrchr(email, '@'); - if (strstr (last_arobas, "@.") != NULL || - strstr (last_arobas, "..") != NULL) + if (strstr(last_arobas, "@.") != NULL || + strstr(last_arobas, "..") != NULL) return 0; for (ch = 1; ch < 32; ch++) { - if (strchr (last_arobas, ch) != NULL) + if (strchr(last_arobas, ch) != NULL) { return 0; break; } } - if (strchr (last_arobas, ' ') != NULL || - strchr (last_arobas, ';') != NULL) + if (strchr(last_arobas, ' ') != NULL || + strchr(last_arobas, ';') != NULL) return 0; // all correct @@ -74,15 +74,15 @@ int e_mail_check (const char *email) //------------------------------------------------- int config_switch (const char *str) { - if (strcasecmp (str, "on") == 0 || strcasecmp (str, "yes") == 0 - || strcasecmp (str, "oui") == 0 || strcasecmp (str, "ja") == 0 - || strcasecmp (str, "si") == 0) + if (strcasecmp(str, "on") == 0 || strcasecmp(str, "yes") == 0 + || strcasecmp(str, "oui") == 0 || strcasecmp(str, "ja") == 0 + || strcasecmp(str, "si") == 0) return 1; - if (strcasecmp (str, "off") == 0 || strcasecmp (str, "no") == 0 - || strcasecmp (str, "non") == 0 || strcasecmp (str, "nein") == 0) + if (strcasecmp(str, "off") == 0 || strcasecmp(str, "no") == 0 + || strcasecmp(str, "non") == 0 || strcasecmp(str, "nein") == 0) return 0; - return atoi (str); + return atoi(str); } const char *ip2str(struct in_addr ip, bool extra_dot) diff --git a/src/common/utils.hpp b/src/common/utils.hpp index 1097bf7..fdd9d40 100644 --- a/src/common/utils.hpp +++ b/src/common/utils.hpp @@ -11,15 +11,15 @@ I deleted malloc.{h,c} because it was redundant; future calls should either use this or depend on the coming segfault. */ # define CREATE(result, type, number) \ - if (!((result) = (type *) calloc ((number), sizeof(type)))) \ + if (!((result) = (type *) calloc((number), sizeof(type)))) \ { perror("SYSERR: malloc failure"); abort(); } else (void)0 # define RECREATE(result,type,number) \ - if (!((result) = (type *) realloc ((result), sizeof(type) * (number))))\ + if (!((result) = (type *) realloc((result), sizeof(type) * (number))))\ { perror("SYSERR: realloc failure"); abort(); } else (void)0 -int remove_control_chars (char *str); -int e_mail_check (const char *email); +int remove_control_chars(char *str); +int e_mail_check(const char *email); int config_switch (const char *str); const char *ip2str(struct in_addr ip, bool extra_dot = false); -- cgit v1.2.3-70-g09d2