void ksystime_timer_start_internal(KTIMER* timer, SYSTIME *time)
{
SYSTIME uptime;
DLIST_ENUM de;
KTIMER* cur;
bool found = false;
ksystime_get_uptime(&uptime);
timer->time.sec = time->sec;
timer->time.usec = time->usec;
systime_add(&uptime, &timer->time, &timer->time);
disable_interrupts();
dlist_enum_start((DLIST**)&__KERNEL->timers, &de);
while (dlist_enum(&de, (DLIST**)&cur))
if (systime_compare(&cur->time, &timer->time) < 0)
{
dlist_add_before((DLIST**)&__KERNEL->timers, (DLIST*)cur, (DLIST*)timer);
found = true;
break;
}
if (!found)
dlist_add_tail((DLIST**)&__KERNEL->timers, (DLIST*)timer);
timer->active = true;
enable_interrupts();
find_shoot_next();
}
pchatbox_t *new_pchatbox(ifreechat_t *ifc, user_t *user) {
pchatbox_t *pchatbox;
dlist_t *pchatbox_list;
char title[128];
GladeXML *xml;
GtkTextBuffer *display_buffer;
pchatbox = (pchatbox_t*)malloc(sizeof(pchatbox_t));
init_chatbox(ifc, pchatbox, PCHATBOX, (void*)user);
pthread_mutex_lock(&(ifc->pchatbox_lock));
dlist_add_tail(&(pchatbox->chatbox_node), &(ifc->pchatbox));
pthread_mutex_unlock(&(ifc->pchatbox_lock));
sprintf(title, "Chat with %s", user->nickname);
gtk_window_set_title((GtkWindow*)pchatbox->window, title);
gtk_image_set_from_file(pchatbox->avatar_image, user->avatar);
gtk_label_set_text(pchatbox->first_label, user->nickname);
gtk_label_set_text(pchatbox->second_label, ""/*user->signature*/);
chatbox_set_sendmsg_func(pchatbox, on_send_message);
show_chatbox(pchatbox);
return pchatbox;
}
int id_generator_push(dlist_t *id_list, int id) {
int *d = (int*) malloc(sizeof(int));
*d = id;
dnode_t *n = dlist_add_tail(id_list, (void*)d);
if(n == NULL) {
log_err("Something wrong when pushing id to list");
return 1;
}
return 0;
}
/* Put a pcb into the delay queue
* @param proc: the process to be put
*/
int en_delay_queue(pcb_t *proc) {
dnode_t* n = dlist_add_tail(delay_queue, proc);
if(!n) {
log_err("Cannot enqueue delay queue");
return _FAILURE;
}
proc->list_node = n;
proc->state = PAUSE;
return _SUCCESS;
}
/* Enqueue a pcb into ready queue,
* set its state to ready,
* and keep a pointer to its inner queue node
*
* @param proc: the pcb to be enqueued
* @return: A pointer to the newly created pcb;
* NULL if creation fails
*/
int en_ready_queue(pcb_t *proc) {
dnode_t *n = dlist_add_tail(ready_queue, proc);
if(!n) {
_debug("Cannot enqueue the pcb\n");
return 1;
}
//log_info("En ready_queue with PID(%d)", proc->pid);
proc->list_node = n;
proc->state = READY;
return 0;
}
/* Enqueue the exit_queue of parent, with the exit_code
*/
int en_zombie_queue(pcb_t* parent, pcb_t* child) {
dnode_t *n = dlist_add_tail(parent->zombie, child);
if(!n) {
log_err("Cannot add exit code to parent PID(%d)", parent->pid);
return 1;
}
log_info("PID(%d) added to zombie queue, q size is %d", child->pid, parent->zombie->size);
child->list_node = n;
child->state = ZOMBIE;
return 0;
}
/* Put a process into wait queue, invoked by Wait() syscall
*/
int en_wait_queue(pcb_t *proc) {
dnode_t *n = dlist_add_tail(wait_queue, proc);
if(!n) {
log_err("Cannot add to wait queue");
return 1;
}
proc->list_node = n;
proc->state = WAIT;
proc->wait_zombie = 1;
log_info("PID(%d) en wait_queue", proc->pid);
return 0;
}
int proc_enqueue(dlist_t *queue, pcb_t *proc) {
if(queue == NULL || proc == NULL) {
log_info("queue or proc is empty");
return 1;
}
dnode_t *n = dlist_add_tail(queue, proc);
if(!n) {
log_err("PID(%d) cannot add to queue");
return 1;
}
proc->list_node = n;
proc->state = WAIT;
return 0;
}
static inline void svc_queue_push(QUEUE* queue, void* buf)
{
CHECK_MAGIC(queue, MAGIC_QUEUE, QUEUE_NAME);
if (queue->pull_waiters)
{
THREAD* thread = queue->pull_waiters;
dlist_remove_head((DLIST**)&queue->pull_waiters);
//patch return value
thread_patch_context(thread, (unsigned int)buf);
svc_thread_wakeup(thread);
}
else
dlist_add_tail(&queue->filled_blocks, (DLIST*)((unsigned int)buf - queue->align_offset));
}
static void check_abusers_in_room(struct chatroom *chat) {
struct aim_chat *a_chat = chat->data;
dlist_t *chat_users = chat->user_list;
struct chat_user *chat_user;
while (chat_users != NULL) {
dlist_t *cur = a_chat->abarray;
chat_user = chat_users->data;
while (cur != NULL) {
if (strstr(chat_user->nname, cur->data)) {
a_chat->abqueue = dlist_add_tail(a_chat->abqueue, xstrdup(chat_user->nname));
break;
}
cur = cur->next;
}
chat_users = chat_users->next;
}
}
static inline void* svc_queue_allocate_buffer(QUEUE* queue, TIME* time)
{
CHECK_MAGIC(queue, MAGIC_QUEUE, QUEUE_NAME);
void* res = NULL;
THREAD* thread = svc_thread_get_current();
if (queue->free_blocks)
{
res = (void*)((unsigned int)(queue->free_blocks) + queue->align_offset);
dlist_remove_head(&queue->free_blocks);
}
else
{
//first - remove from active list
//if called from IRQ context, thread_private.c will raise error
svc_thread_sleep(time, THREAD_SYNC_QUEUE, queue);
dlist_add_tail((DLIST**)&queue->push_waiters, (DLIST*)thread);
}
return res;
}
/* Enqueue a process into the tty queues
*/
int tty_proc_enqueue(dlist_t *tty_queue, pcb_t *proc)
{
//first check if proc is already in the queue
//log_info("Before tty enqueue with PID(%d), now queue size %d", proc->pid, tty_queue->size);
if(!tty_queue){
return 0;
}
//not in the queue, add to the tail
dnode_t *n = dlist_add_tail(tty_queue, proc);
if(!n)
{
log_err("Cannot enqueue the tty queue\n");
return 1;
}
//log_info("Tty enqueue with PID(%d), now queue size %d", proc->pid, tty_queue->size);
proc->list_node = n;
proc->state = WAIT;
return 0;
}
/* A general function to initialize user proc
*
* @return: A pointer to the newly created pcb;
* NULL if creation fails
*/
pcb_t *init_user_proc(pcb_t* parent) {
// Create pcb
pcb_t *proc = (pcb_t*) malloc(sizeof(pcb_t));
if(!proc) {
log_err("Cannot malloc user proc!");
return NULL;
}
bzero(proc, sizeof(pcb_t));
// Create page table
proc->page_table = (pte_t*) malloc(sizeof(pte_t) * GET_PAGE_NUMBER(VMEM_1_SIZE));
if(!proc->page_table) {
log_err("proc->page_table cannot be malloc!");
return NULL;
}
bzero(proc->page_table, sizeof(pte_t) * GET_PAGE_NUMBER(VMEM_1_SIZE));
// Create kernel stack page table
proc->kernel_stack_pages = (pte_t*) malloc(sizeof(pte_t) * KERNEL_STACK_MAXSIZE / PAGESIZE);
if(!proc->kernel_stack_pages) {
log_err("proc->kernel_stack_pages cannot be malloc!");
return NULL;
}
bzero(proc->kernel_stack_pages, sizeof(pte_t) * KERNEL_STACK_MAXSIZE / PAGESIZE);
// Init vitals
proc->init_done = 0;
proc->parent = (struct y_PBC*)parent;
proc->children = dlist_init();
proc->zombie = dlist_init();
proc->pid = get_next_pid();
if(parent) {
dlist_add_tail(parent->children, proc);
}
proc->state = READY;
proc->wait_zombie = 0;
return proc;
}
static inline void find_shoot_next()
{
volatile KTIMER* timers_to_shoot = NULL;
volatile KTIMER* cur;
SYSTIME uptime;
disable_interrupts();
while (__KERNEL->timers)
{
ksystime_get_uptime_internal(&uptime);
if (systime_compare(&__KERNEL->timers->time, &uptime) >= 0)
{
cur = __KERNEL->timers;
cur->active = false;
dlist_remove_head((DLIST**)&__KERNEL->timers);
dlist_add_tail((DLIST**)&timers_to_shoot, (DLIST*)cur);
}
//add to this second events
else if (__KERNEL->timers->time.sec == uptime.sec)
{
__KERNEL->uptime.usec += __KERNEL->cb_ktimer.elapsed(__KERNEL->cb_ktimer_param);
__KERNEL->cb_ktimer.stop(__KERNEL->cb_ktimer_param);
__KERNEL->hpet_value = __KERNEL->timers->time.usec - __KERNEL->uptime.usec;
__KERNEL->cb_ktimer.start(__KERNEL->hpet_value, __KERNEL->cb_ktimer_param);
break;
}
else
break;
}
enable_interrupts();
while (timers_to_shoot)
{
cur = timers_to_shoot;
dlist_remove_head((DLIST**)&timers_to_shoot);
cur->callback(cur->param);
}
}
static inline QUEUE* svc_queue_create(unsigned int block_size, unsigned int blocks_count, unsigned int align)
{
QUEUE* queue = NULL;
int i;
//first, try to allocate space for queue data. In thread's current mempool
unsigned int align_offset = sizeof(DLIST);
if (align > align_offset)
align_offset = align;
void* mem_block = malloc_aligned(blocks_count * (block_size + align_offset), align_offset);
if (mem_block)
{
queue = sys_alloc(sizeof(QUEUE));
if (queue != NULL)
{
queue->align_offset = align_offset;
queue->mem_block = mem_block;
queue->pull_waiters = NULL;
queue->push_waiters = NULL;
DO_MAGIC(queue, MAGIC_QUEUE);
//set all as free
queue->free_blocks = NULL;
queue->filled_blocks = NULL;
for (i = 0; i < blocks_count; ++i)
dlist_add_tail(&queue->free_blocks, (DLIST*)((unsigned int)mem_block + i * (block_size + align_offset)));
}
else
{
free(mem_block);
fatal_error(ERROR_MEM_OUT_OF_SYSTEM_MEMORY, QUEUE_NAME);
}
}
else
error(ERROR_MEM_OUT_OF_HEAP, svc_thread_name(svc_thread_get_current()));
return queue;
}
void parse_ccom(char *cmd, struct chatroom *room, struct pork_acct *acct, int priv) {
struct aim_chat *ccon = room->data;
struct aim_priv *a_priv = acct->data;
dlist_t *temp;
char sn[MAXSNLEN+1];
char msg[MAXSNLEN+1024];
char *pmsg = msg;
cmd[strcspn(cmd,"/")] = '\0';
if(!strncasecmp(cmd, "op ", 3) && (priv >= FULLOPS)) {
cmd += 3;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (check_if_op(sn, room))
return;
ccon->oparray = dlist_add_tail(ccon->oparray, xstrdup(sn));
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been opped.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
} else if(!strncasecmp(cmd, "deop ", 5) && (priv >= FULLOPS)) {
cmd += 5;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (!check_if_op(sn, room))
return;
if (temp = dlist_find(ccon->oparray, sn, (void*)strcmp)) {
free(temp->data);
ccon->oparray = dlist_remove(ccon->oparray, temp);
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been deopped.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "defullop ", 7) && (priv >= DOWNERS)) {
cmd += 9;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (temp = dlist_find(ccon->fullops, sn, (void*)strcmp)) {
free(temp->data);
ccon->fullops = dlist_remove(ccon->fullops, temp);
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been defullopped.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "fullop ", 7) && (priv >= FULLOPS)) {
cmd += 7;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (check_if_fullop(sn, room))
return;
ccon->fullops = dlist_add_tail(ccon->fullops, xstrdup(sn));
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been fullopped.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
} else if(!strncasecmp(cmd, "halfop ", 7) && (priv > HALFOPS)) {
cmd += 7;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (check_if_halfop(sn, room))
return;
ccon->halfops = dlist_add_tail(ccon->halfops, xstrdup(sn));
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been halfopped.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
} else if(!strncasecmp(cmd, "dehalfop ", 9) && (priv > HALFOPS)) {
cmd += 9;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (!check_if_halfop(sn, room))
return;
if (temp = dlist_find(ccon->halfops, sn, (void*)strcmp)) {
free(temp->data);
ccon->halfops = dlist_remove(ccon->halfops, temp);
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been dehalfopped.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "kick ", 5)) {
cmd += 5;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (check_if_imm(sn, room))
return;
if (ccon->chatsends > 1) {
snprintf(msg, MAXSNLEN+127, "kicking %s.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
if ((temp = dlist_find(ccon->banlist, sn, (void*)strcmp)) != NULL) {
free(temp->data);
ccon->banlist = dlist_remove(ccon->banlist, temp);
}
aim_chat_ban(&a_priv->aim_session, ccon->conn, sn);
aim_chat_unban(&a_priv->aim_session, ccon->conn, sn);
} else if(!strncasecmp(cmd, "ban ", 4) && (priv > HALFOPS)) {
cmd += 4;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (check_if_imm(sn, room))
return;
if (ccon->chatsends > 1) {
snprintf(msg, MAXSNLEN+127, "banning %s.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
if (!dlist_find(ccon->banlist, sn, (void*)strcmp))
ccon->banlist = dlist_add_tail(ccon->banlist, xstrdup(sn));
aim_chat_ban(&a_priv->aim_session, ccon->conn, sn);
} else if(!strncasecmp(cmd, "unban ", 6) && (priv > HALFOPS)) {
cmd += 6;
if (!aim_snvalid(cmd))
return;
if (ccon->chatsends > 1) {
snprintf(msg, MAXSNLEN+127, "unbanning %s.", cmd);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
if ((temp = dlist_find(ccon->banlist, cmd, (void*)strcmp)) != NULL) {
free(temp->data);
ccon->banlist = dlist_remove(ccon->banlist, temp);
}
aim_chat_unban(&a_priv->aim_session, ccon->conn, cmd);
} else if(!strncasecmp(cmd, "pause ", 6) && (priv >= FULLOPS)) {
cmd += 6;
banpause = atoi(cmd);
if (banpause < 0)
banpause = 0;
sprintf(msg, "autoban pause set to %g microseconds.", banpause);
if (ccon->chatsends > 1)
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
} else if(!strncasecmp(cmd, "help", 4) && ccon->chatsends) {
char commands[MAXMSGLEN+1];
strcpy(commands, "commands are: !status, !kick, !imm");
if (priv > HALFOPS)
strcat(commands,", !unimm, !ban, !unban, !ab, !unab, !aw, !unaw, !halfop, !dehalfop, !bj");
if (priv > OPS)
strcat(commands,", !ak, !unak, !op, !deop, !fullop, !save, !load");
if (priv > FULLOPS)
strcat(commands,", !defullop");
strcat(commands, ".");
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, commands, strlen(commands), "us-ascii", "en");
} else if(!strncasecmp(cmd, "imm ", 4)) {
cmd += 4;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (check_if_imm(sn, room))
return;
ccon->immlist = dlist_add_tail(ccon->immlist, xstrdup(sn));
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been immed.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
} else if(!strncasecmp(cmd, "unimm ", 6) && (priv > HALFOPS)) {
cmd += 6;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (!check_if_imm(sn, room))
return;
if (temp = dlist_find(ccon->immlist, sn, (void*)strcmp)) {
free(temp->data);
ccon->immlist = dlist_remove(ccon->immlist, temp);
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been unimmed.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "ak ", 3) && (priv > OPS)) {
cmd += 3;
if (!aim_snvalid(cmd))
return;
if (check_if_ak(cmd, room))
return;
normalize(sn, cmd, strlen(cmd) + 1);
ccon->akarray = dlist_add_tail(ccon->akarray, xstrdup(cmd));
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been autokicked.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
check_akusers_in_room(room);
} else if(!strncasecmp(cmd, "ab ", 3) && (priv > HALFOPS)) {
cmd += 3;
if (!aim_snvalid(cmd))
return;
if (check_if_ab(cmd, room))
return;
normalize(sn, cmd, strlen(cmd) + 1);
ccon->abarray = dlist_add_tail(ccon->abarray, xstrdup(cmd));
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been autobanned.", sn);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
check_abusers_in_room(room);
} else if(!strncasecmp(cmd, "aw ", 3) && (priv > HALFOPS)) {
cmd += 3;
if (check_if_aw(cmd, room))
return;
ccon->awarray = dlist_add_tail(ccon->awarray, xstrdup(cmd));
if (ccon->chatsends > 1) {
sprintf(msg, "%s has been autoworded.", cmd);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
} else if(!strncasecmp(cmd, "unak ", 5) && (priv > OPS)) {
cmd += 5;
if (!aim_snvalid(cmd))
return;
if (!check_if_ak(cmd, room))
return;
if (temp = dlist_find(ccon->akarray, cmd, (void*)strcmp)) {
free(temp->data);
ccon->akarray = dlist_remove(ccon->akarray, temp);
if (0) { //ccon->chatsends > 1) {
sprintf(msg, "%s has been unautokicked.", cmd);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "unab ", 5) && (priv > HALFOPS)) {
cmd += 5;
if (!aim_snvalid(cmd))
return;
if (!check_if_ab(cmd, room))
return;
if (temp = dlist_find(ccon->abarray, cmd, (void*)strcmp)) {
free(temp->data);
ccon->abarray = dlist_remove(ccon->abarray, temp);
if (0) { //ccon->chatsends > 1) {
sprintf(msg, "%s has been unautobanned.", cmd);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "unaw ", 5) && (priv > HALFOPS)) {
cmd += 5;
if (!check_if_aw(cmd, room))
return;
if (temp = dlist_find(ccon->awarray, cmd, (void*)strcmp)) {
free(temp->data);
ccon->awarray = dlist_remove(ccon->awarray, temp);
if (ccon->chatsends > 1) {
snprintf(msg, 1024, "%s has been unautoworded.", cmd);
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "status ", 7) && ccon->chatsends) {
strcpy(msg, "");
cmd += 7;
if (!aim_snvalid(cmd))
return;
partial_nick(cmd, sn, room);
if (check_if_fullop(sn, room)) {
sprintf(msg, "%s is a full op.", sn);
} else if (check_if_op(sn, room)) {
sprintf(msg, "%s is an op.", sn);
} else if (check_if_halfop(sn, room)) {
sprintf(msg, "%s is a half op", sn);
if (check_if_imm(sn, room))
strcat(msg, " and immune");
strcat(msg, ".");
} else if (check_if_imm(sn, room)) {
sprintf(msg, "%s is immune.", sn);
}
if (strlen(msg))
aim_chat_send_im(&a_priv->aim_session, ccon->conn,
0, pmsg, strlen(msg), "us-ascii", "en");
} else if(!strncasecmp(cmd, "chatsends ", 10) && (priv >= FULLOPS)) {
int chatsends;
cmd += 10;
chatsends = atoi(cmd);
if ((chatsends >= 0) && (chatsends <= 2)) {
ccon->chatsends = chatsends;
if (ccon->chatsends > 1) {
sprintf(msg, "chatsends now set to %d.", ccon->chatsends);
aim_chat_send_im(&a_priv->aim_session, ccon->conn, 0, msg, strlen(msg), "us-ascii", "en");
}
}
} else if(!strncasecmp(cmd, "save", 4) && (priv >= FULLOPS)) {
if (!write_room(ccon)) {
screen_err_msg("unable to save config for room %s.\n", ccon->title);
}
} else if(!strncasecmp(cmd, "load ", 5) && (priv >= FULLOPS)) {
if (!read_room(ccon, &cmd[5])) {
screen_err_msg("unable to load config for room %s.\n", &cmd[5]);
}
} else if(!strncasecmp(cmd, "bj", 2) && (priv > HALFOPS)) {
ccon->banjoin = !ccon->banjoin;
if (ccon->chatsends > 1) {
sprintf(msg, "banjoin: %s.", ccon->banjoin?"on":"off");
aim_chat_send_im(&a_priv->aim_session, ccon->conn, 0, msg, strlen(msg), "us-ascii", "en");
}
}
}
void sealpac_puts(const char * string)
{
MD5_CTX ctx;
i18nstr_t * istr;
i18nstr_t * newstr;
struct dlist_head * entry;
int comp;
if (!string) return;
if (strlen(string)<=0) return;
/* Allocate a new entry */
newstr = MALLOC(sizeof(i18nstr_t));
if (!newstr)
{
printf("%s: memory allocation failed!\n",__func__);
return;
}
/* fill up this entry */
newstr->string = STRDUP(string);
if (!newstr->string)
{
printf("%s: memory allocation failed!\n",__func__);
return;
}
MD5Init(&ctx);
MD5Update(&ctx, (uint8_t *)newstr->string, strlen(newstr->string));
MD5Final(newstr->digest, &ctx);
/* Look for insert point */
entry = NULL;
while ((entry = dlist_get_next(entry, &g_i18n_strings)))
{
istr = dlist_entry(entry, i18nstr_t, list);
comp = compare_i18nstr(istr, newstr);
if (comp > 0) /* istr > newstr */
{
dlist_add_tail(&newstr->list, entry);
if (o_verbose > 1) verbose("Add string '%s'\n",newstr->string);
return;
}
else if (comp == 0) /* digest conflict */
{
if (strcmp(newstr->string, istr->string)==0)
{
if (o_verbose > 1) verbose("Duplicated string : '%s'\n", string);
}
else
{
printf("ERROR!! Digest Conflict. Please change the string '%s'\n",string);
}
FREE(newstr->string);
FREE(newstr);
return;
}
}
dlist_add_tail(&newstr->list, &g_i18n_strings);
if (o_verbose > 1) verbose("Add string '%s'\n",newstr->string);
return;
}
int init() {
/*
* Let's just check the file and make sure it makes sense. We just
* need to be careful not to run past the end because we'll crash
*/
tar_hdr *tar_header;
char filename[110];
char timebuf[100];
int uid;
int gid;
int size;
int mtime;
int round_size;
int remaining;
file_struct *pfile;
int err;
char *initrd_addr;
char *initrd_end;
size_t initrd_len;
char *basenam;
anvil_sysinfo->initrd_info.base_addr;
//anvil_syslog(0, "INITRD: Checking the tar file from %016lx len %016lx\n",
// anvil_sysinfo->initrd_info.base_addr, anvil_sysinfo->initrd_info.length);
initrd_len = anvil_sysinfo->initrd_info.length;
//anvil_syslog(0, "INITRD: End = %016lx\n", anvil_sysinfo->initrd_info.base_addr + anvil_sysinfo->initrd_info.length);
dlist_init(&filelist);
initrd_addr = (char *)mmap(0, initrd_len, PROT_READ, MAP_PHYS | MAP_PRIVATE, -1, anvil_sysinfo->initrd_info.base_addr);
tar_header = (tar_hdr *)initrd_addr;
initrd_end = initrd_addr + initrd_len;
//anvil_syslog(0, "INITRD file list\n");
while (1) {
/* Check we haven't reached the end of the tar file */
remaining = initrd_end - (char *)tar_header;
//kdebug("Remaining = %d\n", remaining);
if (remaining <= 1024) {
/* There are always 1024 NUL chars at the end of the file */
break;
}
/* Check the filename */
strncpy(filename, tar_header->filename, 99);
//anvil_syslog(0, "%12s - ", filename);
basenam = basename(filename);
uid = strtol(tar_header->uid, NULL, 8);
gid = strtol(tar_header->gid, NULL, 8);
size = strtol(tar_header->size, NULL, 8);
mtime = strtol(tar_header->mtime, NULL, 8);
if (size == 0) {
round_size = 0;
}
else {
round_size = (((size-1)/512)+1)*512;
}
strcpy(timebuf, asctime(gmtime((const time_t *)&mtime)));
//anvil_syslog(0, "%12s - ", basenam);
//anvil_syslog(0, "%s %3d,%3d %7d bytes %s", tar_header->filemode+3, uid,
// gid, size, timebuf);
pfile = (file_struct *)malloc(sizeof(file_struct) + strlen(filename) + 1);
pfile->open = 0;
pfile->offs = (char *)tar_header - initrd_addr;
pfile->size = size;
/* The data starts right after the header */
pfile->addr = (char *)(tar_header + 1);
strcpy(pfile->filename, basenam);
dlist_add_tail(&filelist, (dlist_item_t *)pfile);
tar_header = (tar_hdr *)((char *)tar_header + 512 + round_size);
}
//anvil_syslog(0, "INITRD file list end\n");
pfile = (file_struct *)dlist_peek_head(&filelist);
while (pfile) {
//anvil_syslog(0, "*** INITRD: Found file %s\n", pfile->filename);
pfile = (file_struct *)dlist_peek_next(&filelist, (dlist_item_t *)pfile);
}
/* All okay so return 0 */
return 0;
}
static inline void utlLog_queue_push(UtlLogQueue *queue, UtlLogMsg *msg)
{
dlist_add_tail(&msg->list, &queue->list_head);
}
void storage_register_handler(STORAGE* storage, STORAGE_HOST_CB* host_cb)
{
dlist_add_tail((DLIST**)&storage->host_cb, (DLIST*)host_cb);
}
void check_ab_queues() {
dlist_t *cur;
struct chatroom *chat;
struct pork_acct *acct;
struct aim_chat *a_chat;
struct aim_priv *priv;
int refnum = 0;
char msg[MAXSNLEN+1024];
dlist_t *temp;
while ((cur = pork_acct_find(refnum)) != NULL) {
refnum++;
acct = cur->data;
if (acct->proto->protocol != PROTO_AIM)
continue;
priv = acct->data;
for (cur = acct->chat_list; cur != NULL; cur = cur->next) {
chat = cur->data;
a_chat = chat->data;
if (a_chat->abqueue != NULL) {
if (check_if_imm(a_chat->abqueue->data,
chat)) {
free(a_chat->abqueue->data);
dlist_remove_head(&a_chat->abqueue);
return;
}
if (a_chat->chatsends > 1) {
snprintf(msg, MAXSNLEN+1023,
"banning %s.",
(char*)a_chat->abqueue->data);
aim_chat_send_im(&priv->aim_session,
a_chat->conn, 0, msg,
strlen(msg), "us-ascii", "en");
}
if (!dlist_find(a_chat->banlist, a_chat->abqueue->data, (void*)strcmp))
a_chat->banlist = dlist_add_tail(a_chat->banlist, xstrdup(a_chat->abqueue->data));
aim_chat_ban(&priv->aim_session, a_chat->conn,
a_chat->abqueue->data);
free(a_chat->abqueue->data);
dlist_remove_head(&a_chat->abqueue);
}
if (a_chat->akqueue != NULL) {
if (check_if_imm(a_chat->akqueue->data,
chat)) {
free(a_chat->akqueue->data);
dlist_remove_head(&a_chat->akqueue);
return;
}
if (a_chat->chatsends > 1) {
snprintf(msg, MAXSNLEN+1023,
"kicking %s.",
(char*)a_chat->akqueue->data);
aim_chat_send_im(&priv->aim_session,
a_chat->conn, 0, msg,
strlen(msg), "us-ascii", "en");
}
if ((temp = dlist_find(a_chat->banlist, a_chat->akqueue->data, (void*)strcmp)) != NULL) {
free(temp->data);
a_chat->banlist = dlist_remove(a_chat->banlist, temp);
}
aim_chat_ban(&priv->aim_session, a_chat->conn,
a_chat->akqueue->data);
aim_chat_unban(&priv->aim_session, a_chat->conn,
a_chat->akqueue->data);
free(a_chat->akqueue->data);
dlist_remove_head(&a_chat->akqueue);
}
}
}
}
