Mercurial > pidgin
view src/core.c @ 3471:7fb93ecd631c
[gaim-migrate @ 3522]
whoops.
committer: Tailor Script <tailor@pidgin.im>
author | Sean Egan <seanegan@gmail.com> |
---|---|
date | Thu, 29 Aug 2002 21:12:00 +0000 |
parents | 1e12a24b7f27 |
children | 3da42b64304e |
line wrap: on
line source
/* * gaim * * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include <glib.h> #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/stat.h> #include <sys/un.h> #include <unistd.h> #include <errno.h> #include <signal.h> #include <getopt.h> #include <stdarg.h> #include <string.h> #include "gaim.h" static gint UI_fd = -1; GSList *uis = NULL; static guchar *UI_build(guint32 *len, guchar type, guchar subtype, va_list args) { guchar *buffer; guint32 pos; int size; void *data; *len = sizeof(guchar) * 2 + 4; buffer = g_malloc(*len); pos = 0; memcpy(buffer + pos, &type, sizeof(type)); pos += sizeof(type); memcpy(buffer + pos, &subtype, sizeof(subtype)); pos += sizeof(subtype); /* we come back and do size last */ pos += 4; size = va_arg(args, int); while (size != -1) { *len += size; buffer = g_realloc(buffer, *len); data = va_arg(args, void *); memcpy(buffer + pos, data, size); pos += size; size = va_arg(args, int); } pos -= sizeof(guchar) * 2 + 4; /* now we do size */ memcpy(buffer + sizeof(guchar) * 2, &pos, 4); return buffer; } gint UI_write(struct UI *ui, guchar *data, gint len) { gint sent; /* we'll let the write silently fail because the read will pick it up as dead */ g_io_channel_write(ui->channel, data, len, &sent); return sent; } void UI_build_write(struct UI *ui, guchar type, guchar subtype, ...) { va_list ap; gchar *data; guint32 len; va_start(ap, subtype); data = UI_build(&len, type, subtype, ap); va_end(ap); UI_write(ui, data, len); g_free(data); } void UI_broadcast(guchar *data, gint len) { GSList *u = uis; while (u) { struct UI *ui = u->data; UI_write(ui, data, len); u = u->next; } } void UI_build_broadcast(guchar type, guchar subtype, ...) { va_list ap; gchar *data; guint32 len; if (!uis) return; va_start(ap, subtype); data = UI_build(&len, type, subtype, ap); va_end(ap); UI_broadcast(data, len); g_free(data); } static void meta_handler(struct UI *ui, guchar subtype, guchar *data) { switch (subtype) { case CUI_META_LIST: break; case CUI_META_QUIT: while (uis) { ui = uis->data; uis = g_slist_remove(uis, ui); g_io_channel_close(ui->channel); g_source_remove(ui->inpa); g_free(ui); } do_quit(); break; case CUI_META_DETACH: uis = g_slist_remove(uis, ui); g_io_channel_close(ui->channel); g_source_remove(ui->inpa); g_free(ui); break; default: debug_printf("unhandled meta subtype %d\n", subtype); break; } } static void plugin_handler(struct UI *ui, guchar subtype, guchar *data) { #ifdef GAIM_PLUGINS guint id; struct gaim_plugin *p; switch (subtype) { /* case CUI_PLUGIN_LIST: break; */ case CUI_PLUGIN_LOAD: p = load_plugin(data); /* XXX need to broadcast to UIs that plugin has been loaded */ break; case CUI_PLUGIN_UNLOAD: memcpy(&id, data, sizeof(id)); p = g_list_nth_data(plugins, id); if (p) { unload_plugin(p); /* XXX need to broadcast to UIs that plugin has been unloaded */ } break; case CUI_PLUGIN_RELOAD: memcpy(&id, data, sizeof(id)); p = g_list_nth_data(plugins, id); if (p) { p = reload_plugin(p); /* XXX need to broadcast to UIs that plugin has been reloaded */ } break; default: debug_printf("unhandled plugin subtype %d\n", subtype); break; } #endif } static void user_handler(struct UI *ui, guchar subtype, guchar *data) { guint id; struct aim_user *u; switch (subtype) { /* case CUI_USER_LIST: break; case CUI_USER_ADD: break; case CUI_USER_REMOVE: break; case CUI_USER_MODIFY: break; */ case CUI_USER_SIGNON: if (!data) return; memcpy(&id, data, sizeof(id)); u = g_slist_nth_data(aim_users, id); if (u) serv_login(u); /* don't need to do anything here because the UI will get updates from other handlers */ break; default: debug_printf("unhandled user subtype %d\n", subtype); break; } } static void message_handler(struct UI *ui, guchar subtype, guchar *data) { switch (subtype) { case CUI_MESSAGE_LIST: break; case CUI_MESSAGE_SEND: if (!data) return; { guint id; struct gaim_connection *gc; guint len; char *who, *msg; gint flags; int pos = 0; memcpy(&id, data + pos, sizeof(id)); pos += sizeof(id); gc = g_slist_nth_data(connections, id); if (!gc) return; memcpy(&len, data + pos, sizeof(len)); pos += sizeof(len); who = g_strndup(data + pos, len + 1); pos += len; memcpy(&len, data + pos, sizeof(len)); pos += sizeof(len); msg = g_strndup(data + pos, len + 1); pos += len; memcpy(&flags, data + pos, sizeof(flags)); serv_send_im(gc, who, msg, -1, flags); g_free(who); g_free(msg); } break; case CUI_MESSAGE_RECV: break; default: debug_printf("unhandled message subtype %d\n", subtype); break; } } static gint gaim_recv(GIOChannel *source, guchar *buf, gint len) { gint total = 0; gint cur; while (total < len) { if (g_io_channel_read(source, buf + total, len - total, &cur) != G_IO_ERROR_NONE) return -1; if (cur == 0) return total; total += cur; } return total; } static gboolean UI_readable(GIOChannel *source, GIOCondition cond, gpointer data) { struct UI *ui = data; guchar type; guchar subtype; guint32 len; guchar *in; /* no byte order worries! this'll change if we go to TCP */ if (gaim_recv(source, &type, sizeof(type)) != sizeof(type)) { debug_printf("UI has abandoned us!\n"); uis = g_slist_remove(uis, ui); g_io_channel_close(ui->channel); g_source_remove(ui->inpa); g_free(ui); return FALSE; } if (gaim_recv(source, &subtype, sizeof(subtype)) != sizeof(subtype)) { debug_printf("UI has abandoned us!\n"); uis = g_slist_remove(uis, ui); g_io_channel_close(ui->channel); g_source_remove(ui->inpa); g_free(ui); return FALSE; } if (gaim_recv(source, (guchar *)&len, sizeof(len)) != sizeof(len)) { debug_printf("UI has abandoned us!\n"); uis = g_slist_remove(uis, ui); g_io_channel_close(ui->channel); g_source_remove(ui->inpa); g_free(ui); return FALSE; } if (len) { in = g_new0(guchar, len); if (gaim_recv(source, in, len) != len) { debug_printf("UI has abandoned us!\n"); uis = g_slist_remove(uis, ui); g_io_channel_close(ui->channel); g_source_remove(ui->inpa); g_free(ui); return FALSE; } } else in = NULL; switch (type) { case CUI_TYPE_META: meta_handler(ui, subtype, in); break; case CUI_TYPE_PLUGIN: plugin_handler(ui, subtype, in); break; case CUI_TYPE_USER: user_handler(ui, subtype, in); break; /* case CUI_TYPE_CONN: conn_handler(ui, subtype, in); break; case CUI_TYPE_BUDDY: buddy_handler(ui, subtype, in); break; */ case CUI_TYPE_MESSAGE: message_handler(ui, subtype, in); break; /* case CUI_TYPE_CHAT: chat_handler(ui, subtype, in); break; */ default: debug_printf("unhandled type %d\n", type); break; } if (in) g_free(in); return TRUE; } static gboolean socket_readable(GIOChannel *source, GIOCondition cond, gpointer data) { struct sockaddr_un saddr; gint len; gint fd; struct UI *ui; if ((fd = accept(UI_fd, (struct sockaddr *)&saddr, &len)) == -1) return FALSE; ui = g_new0(struct UI, 1); uis = g_slist_append(uis, ui); ui->channel = g_io_channel_unix_new(fd); ui->inpa = g_io_add_watch(ui->channel, G_IO_IN | G_IO_HUP | G_IO_ERR, UI_readable, ui); g_io_channel_unref(ui->channel); debug_printf("got one\n"); return TRUE; } static gint open_socket() { struct sockaddr_un saddr; gint fd; if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) != -1) { mode_t m = umask(0177); saddr.sun_family = AF_UNIX; g_snprintf(saddr.sun_path, 108, "%s/gaim_%s.%d", g_get_tmp_dir(), g_get_user_name(), getpid()); if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) != -1) listen(fd, 100); else { g_log(NULL, G_LOG_LEVEL_CRITICAL, "Failed to assign %s to a socket (Error: %s)", saddr.sun_path, strerror(errno)); return -1; } umask(m); } else g_log(NULL, G_LOG_LEVEL_CRITICAL, "Unable to open socket: %s", strerror(errno)); return fd; } int core_main() { /* GMainLoop *loop; */ GIOChannel *channel; UI_fd = open_socket(); if (UI_fd < 0) return 1; channel = g_io_channel_unix_new(UI_fd); g_io_add_watch(channel, G_IO_IN, socket_readable, NULL); g_io_channel_unref(channel); /* loop = g_main_new(TRUE); g_main_run(loop); */ return 0; } void core_quit() { char buf[1024]; close(UI_fd); sprintf(buf, "%s/gaim_%s.%d", g_get_tmp_dir(), g_get_user_name(), getpid()); unlink(buf); debug_printf("Removed core\n"); }