commit 875133d9f678819dfad5caa4d5600dff49635222ec4a0be51a8d420d321c49db Author: OBS User unknown Date: Mon May 21 02:39:49 2007 +0000 OBS-URL: https://build.opensuse.org/package/show/openSUSE:Factory/pidgin?expand=0&rev=1 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/pidgin-2.0.0.tar.bz2 b/pidgin-2.0.0.tar.bz2 new file mode 100644 index 0000000..5770859 --- /dev/null +++ b/pidgin-2.0.0.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d700a95fbce796b4a9e5c2fb07aad8c24402f38a795c8eb51a44e000a8400cff +size 7521328 diff --git a/pidgin-NLD-smiley-theme.tar.bz2 b/pidgin-NLD-smiley-theme.tar.bz2 new file mode 100644 index 0000000..d587245 --- /dev/null +++ b/pidgin-NLD-smiley-theme.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9b4f9e92f0e8ebc473e72a3cf8d8ae488fde177088ba61c1569f86093c9d5c6e +size 20019 diff --git a/pidgin-Tango-smiley-theme.tar.bz2 b/pidgin-Tango-smiley-theme.tar.bz2 new file mode 100644 index 0000000..c86a206 --- /dev/null +++ b/pidgin-Tango-smiley-theme.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3204686fdc32b330aedac3c7e5cd8ac45deedc4128f01cc1878c2ea93e47f4b8 +size 13938 diff --git a/pidgin-check.patch b/pidgin-check.patch new file mode 100644 index 0000000..92ee2ed --- /dev/null +++ b/pidgin-check.patch @@ -0,0 +1,17 @@ +Fix autoreconf for latest version of check. + +--- configure.ac ++++ configure.ac +@@ -1938,11 +1938,7 @@ + dnl ####################################################################### + dnl # Check for check + dnl ####################################################################### +-PKG_CHECK_MODULES(CHECK,[check >= 0.9.4],:,[ +- ifdef([AM_PATH_CHECK], +- [AM_PATH_CHECK(0.8.2,:,:)], +- [AC_MSG_RESULT([no, testing is disabled])]) +- ]) ++PKG_CHECK_MODULES(CHECK,[check >= 0.9.4],:,[AC_MSG_RESULT([no, testing is disabled])]) + AM_CONDITIONAL(HAVE_CHECK, [test "x$CHECK_LIBS" != "x"]) + AC_SUBST(CHECK_CFLAGS) + AC_SUBST(CHECK_LIBS) diff --git a/pidgin-gnome-keyring.patch b/pidgin-gnome-keyring.patch new file mode 100644 index 0000000..56e6d5d --- /dev/null +++ b/pidgin-gnome-keyring.patch @@ -0,0 +1,167 @@ +--- 2.0b4-my/configure.ac 2006-11-13 18:29:02.830447000 +0800 ++++ 2.0b4-my2/configure.ac 2006-11-13 17:05:20.491984000 +0800 +@@ -1783,5 +1783,19 @@ + LDFLAGS="$orig_LDFLAGS" + fi + ++dnl ####################################################################### ++dnl # Check for gnome-keyring ++dnl #--enable-gnome-keyring=(yes|no) ++dnl ####################################################################### ++AC_ARG_ENABLE(gnome-keyring, ++ AC_HELP_STRING([--enable-gnome-keyring], ++ [use gnome keyring for storing password [default=no]]),, ++ enable_gnome_keyring=no) ++if test "x$enable_gnome_keyring" = "xyes"; then ++ PKG_CHECK_MODULES(PURPLE_KEYRING, ++ gnome-keyring-1, ++ AC_DEFINE(VINO_ENABLE_KEYRING, [], [Set if we should use gnome-keyring])) ++fi ++ + + AC_MSG_CHECKING(for me pot o' gold) +--- 2.0b4-my/libpurple/Makefile.am 2006-10-19 01:38:16.000000000 +0800 ++++ 2.0b4-my2/libpurple/Makefile.am 2006-11-13 18:28:51.383417000 +0800 +@@ -221,6 +221,7 @@ + $(LIBXML_LIBS) \ + $(LIBNM_LIBS) \ + $(STATIC_LINK_LIBS) \ ++ $(PURPLE_KEYRING_LIBS) \ + $(INTLLIBS) \ + -lm + +@@ -233,5 +234,6 @@ + $(GLIB_CFLAGS) \ + $(DEBUG_CFLAGS) \ + $(DBUS_CFLAGS) \ ++ $(PURPLE_KEYRING_CFLAGS) \ + $(LIBXML_CFLAGS) \ + $(LIBNM_CFLAGS) +--- 2.0b4-my/libpurple/account.c 2006-10-19 01:38:16.000000000 +0800 ++++ 2.0b4-my2/libpurple/account.c 2006-11-13 18:26:19.409755000 +0800 +@@ -40,6 +40,13 @@ + #include "util.h" + #include "xmlnode.h" + ++#ifdef PURPLE_ENABLE_KEYRING ++#include ++ ++static char * purple_account_get_password_from_keyring (const char *_prpl, const char *_user); ++static gboolean purple_account_set_password_in_keyring (const char *_prpl, const char *_user, const char *password); ++#endif ++ + /* TODO: Should use PurpleValue instead of this? What about "ui"? */ + typedef struct + { +@@ -321,8 +328,13 @@ + if (purple_account_get_remember_password(account) && + ((tmp = purple_account_get_password(account)) != NULL)) + { ++#ifdef PURPLE_ENABLE_KEYRING ++ purple_account_set_password_in_keyring( purple_account_get_protocol_id(account), ++ purple_account_get_username(account), tmp); ++#else + child = xmlnode_new_child(node, "password"); + xmlnode_insert_data(child, tmp, -1); ++#endif + } + + if ((tmp = purple_account_get_alias(account)) != NULL) +@@ -703,17 +715,30 @@ + } + + ret = purple_account_new(name, _purple_oscar_convert(name, protocol_id)); /* XXX: */ +- g_free(name); +- g_free(protocol_id); +- +- /* Read the password */ +- child = xmlnode_get_child(node, "password"); +- if ((child != NULL) && ((data = xmlnode_get_data(child)) != NULL)) ++ gboolean got_pwd = FALSE; ++#ifdef PURPLE_ENABLE_KEYRING ++ data = purple_account_get_password_from_keyring(protocol_id, name); ++ if (data) + { ++ got_pwd = TRUE; + purple_account_set_remember_password(ret, TRUE); + purple_account_set_password(ret, data); + g_free(data); + } ++#endif ++ if (!got_pwd) ++ { ++ /* Read the password */ ++ child = xmlnode_get_child(node, "password"); ++ if ((child != NULL) && ((data = xmlnode_get_data(child)) != NULL)) ++ { ++ purple_account_set_remember_password(ret, TRUE); ++ purple_account_set_password(ret, data); ++ g_free(data); ++ } ++ } ++ g_free(name); ++ g_free(protocol_id); + + /* Read the alias */ + child = xmlnode_get_child(node, "alias"); +@@ -2352,3 +2377,60 @@ + + gaim_signals_unregister_by_instance(gaim_accounts_get_handle()); + } ++ ++#ifdef PURPLE_ENABLE_KEYRING ++static char * ++purple_account_get_password_from_keyring(const char *_prpl, const char *_user) ++{ ++ GnomeKeyringNetworkPasswordData *found_item; ++ GnomeKeyringResult result; ++ GList *matches; ++ char *password; ++ ++ matches = NULL; ++ ++ result = gnome_keyring_find_network_password_sync ( ++ _user, /* user */ ++ NULL, /* domain */ ++ "gaim.local", /* server */ ++ NULL, /* object */ ++ _prpl, /* protocol */ ++ NULL, /* authtype */ ++ 1863, /* port */ ++ &matches); ++ ++ if (result != GNOME_KEYRING_RESULT_OK) ++ return NULL; ++ ++ g_assert (matches != NULL && matches->data != NULL); ++ ++ found_item = (GnomeKeyringNetworkPasswordData *) matches->data; ++ ++ password = g_strdup (found_item->password); ++ ++ gnome_keyring_network_password_list_free (matches); ++ ++ return password; ++} ++ ++static gboolean ++purple_account_set_password_in_keyring (const char *_prpl, const char *_user, const char *_password) ++{ ++ GnomeKeyringResult result; ++ guint32 item_id; ++ ++ result = gnome_keyring_set_network_password_sync ( ++ NULL, /* default keyring */ ++ _user, /* user */ ++ NULL, /* domain */ ++ "gaim.local", /* server */ ++ NULL, /* object */ ++ _prpl, /* protocol */ ++ NULL, /* authtype */ ++ 1863, /* port */ ++ _password, /* password */ ++ &item_id); ++ ++ return result == GNOME_KEYRING_RESULT_OK; ++} ++#endif diff --git a/pidgin-nonblock-aim.patch b/pidgin-nonblock-aim.patch new file mode 100644 index 0000000..0bb91d6 --- /dev/null +++ b/pidgin-nonblock-aim.patch @@ -0,0 +1,487 @@ +diff -upr gaim-1.5.0/libgaim/protocols/oscar/aim.h gaim-1.5.0-new/libgaim/protocols/oscar/aim.h +--- gaim-1.5.0/libpurple/protocols/oscar/aim.h 2005-08-07 23:36:16.000000000 -0500 ++++ gaim-1.5.0-new/libpurple/protocols/oscar/aim.h 2005-09-28 11:29:23.000000000 -0500 +@@ -35,6 +35,8 @@ + #include "libc_interface.h" + #endif + ++#include "gaim-io.h" ++ + #ifdef __cplusplus + extern "C" { + #endif +@@ -310,8 +312,13 @@ struct client_info_s { + #define AIM_FRAMETYPE_FLAP 0x0000 + #define AIM_FRAMETYPE_OFT 0x0001 + ++typedef struct aim_frame_s aim_frame_t; ++ + typedef struct aim_conn_s { + int fd; ++ GaimIO *io; ++ aim_frame_t *current_frame; ++ int current_payload_len; + fu16_t type; + fu16_t subtype; + flap_seqnum_t seqnum; +@@ -346,7 +353,7 @@ typedef struct aim_bstream_s { + fu32_t offset; + } aim_bstream_t; + +-typedef struct aim_frame_s { ++struct aim_frame_s { + fu8_t hdrtype; /* defines which piece of the union to use */ + union { + struct { +@@ -363,7 +370,7 @@ typedef struct aim_frame_s { + aim_conn_t *conn; /* the connection it came in on/is going out on */ + fu8_t handled; /* 0 = new, !0 = been handled */ + struct aim_frame_s *next; +-} aim_frame_t; ++}; + + typedef struct aim_msgcookie_s { + fu8_t cookie[8]; +diff -upr gaim-1.5.0/libgaim/protocols/oscar/aim_internal.h gaim-1.5.0-new/libgaim/protocols/oscar/aim_internal.h +--- gaim-1.5.0/libgaim/protocols/oscar/aim_internal.h 2005-03-06 22:51:56.000000000 -0600 ++++ gaim-1.5.0-new/libgaim/protocols/oscar/aim_internal.h 2005-09-28 11:29:23.000000000 -0500 +@@ -102,8 +102,8 @@ faim_internal int aim_parse_unknown(aim_ + faim_internal void aim_clonehandlers(aim_session_t *sess, aim_conn_t *dest, aim_conn_t *libgaim); + + /* rxqueue.c */ +-faim_internal int aim_recv(int fd, void *buf, size_t count); +-faim_internal int aim_bstream_recv(aim_bstream_t *bs, int fd, size_t count); ++faim_internal int aim_recv(aim_conn_t *conn, void *buf, size_t count); ++faim_internal int aim_bstream_recv(aim_bstream_t *bs, aim_conn_t *conn, size_t count); + faim_internal void aim_rxqueue_cleanbyconn(aim_session_t *sess, aim_conn_t *conn); + faim_internal void aim_frame_destroy(aim_frame_t *); + +diff -upr gaim-1.5.0/libgaim/protocols/oscar/conn.c gaim-1.5.0-new/libgaim/protocols/oscar/conn.c +--- gaim-1.5.0/libgaim/protocols/oscar/conn.c 2005-07-09 14:26:51.000000000 -0500 ++++ gaim-1.5.0-new/libgaim/protocols/oscar/conn.c 2005-09-28 11:29:23.000000000 -0500 +@@ -161,6 +161,9 @@ static void connkill_real(aim_session_t + if ((*deadconn)->fd != -1) + aim_conn_close(*deadconn); + ++ if ((*deadconn)->io) ++ gaim_io_destroy ((*deadconn)->io); ++ + /* + * This will free ->internal if it necessary... + */ +@@ -218,6 +221,7 @@ static void aim_conn_init(aim_conn_t *de + return; + + deadconn->fd = -1; ++ deadconn->io = NULL; + deadconn->subtype = -1; + deadconn->type = -1; + deadconn->seqnum = 0; +@@ -304,8 +308,12 @@ faim_export void aim_conn_close(aim_conn + { + aim_rxcallback_t userfunc; + +- if (deadconn->fd >= 3) ++ if (deadconn->io) { ++ gaim_io_destroy (deadconn->io); ++ deadconn->io = NULL; ++ } else if (deadconn->fd >= 3) { + close(deadconn->fd); ++ } + + deadconn->fd = -1; + +@@ -559,6 +567,7 @@ faim_internal aim_conn_t *aim_cloneconn( + return NULL; + + conn->fd = libgaim->fd; ++ conn->io = gaim_io_new (conn->fd); + conn->type = libgaim->type; + conn->subtype = libgaim->subtype; + conn->seqnum = libgaim->seqnum; +@@ -606,6 +615,7 @@ faim_export aim_conn_t *aim_newconn(aim_ + + connstruct->sessv = (void *)sess; + connstruct->type = type; ++ connstruct->io = NULL; + + if (!dest) { /* just allocate a struct */ + connstruct->fd = -1; +diff -upr gaim-1.5.0/libgaim/protocols/oscar/ft.c gaim-1.5.0-new/libgaim/protocols/oscar/ft.c +--- gaim-1.5.0/libgaim/protocols/oscar/ft.c 2005-08-07 23:36:17.000000000 -0500 ++++ gaim-1.5.0-new/libgaim/protocols/oscar/ft.c 2005-09-28 11:29:23.000000000 -0500 +@@ -630,9 +630,9 @@ static int handlehdr_odc(aim_session_t * + + while (payloadlength - recvd) { + if (payloadlength - recvd >= 1024) +- i = aim_recv(conn->fd, &msg[recvd], 1024); ++ i = aim_recv(conn, &msg[recvd], 1024); + else +- i = aim_recv(conn->fd, &msg[recvd], payloadlength - recvd); ++ i = aim_recv(conn, &msg[recvd], payloadlength - recvd); + if (i <= 0) { + free(msg); + free(snptr); +diff -upr gaim-1.5.0/libgaim/protocols/oscar/oscar.c gaim-1.5.0-new/libgaim/protocols/oscar/oscar.c +--- gaim-1.5.0/libgaim/protocols/oscar/oscar.c 2005-08-11 19:57:27.000000000 -0500 ++++ gaim-1.5.0-new/libgaim/protocols/oscar/oscar.c 2005-09-28 11:29:24.000000000 -0500 +@@ -1580,7 +1580,7 @@ static void oscar_callback(gpointer data + gaim_debug_error("oscar", "Waiting to be destroyed\n"); + return; + } +- } else { ++ } else if (!conn->io || !gaim_io_is_connected (conn->io)) { + if ((conn->type == AIM_CONN_TYPE_BOS) || + !(aim_getconn_type(od->sess, AIM_CONN_TYPE_BOS))) { + gaim_debug_error("oscar", +@@ -3243,6 +3243,11 @@ static void oscar_sendfile_connected(gpo + return; + } + ++static void oscar_sendfile_ready_to_xfer (GaimIO *io, GaimXfer *xfer) ++{ ++ gaim_xfer_start(xfer, xfer->fd, NULL, 0); ++} ++ + /* + * This is called when a buddy sends us some file info. This happens when they + * are sending a file to you, and you have just established a connection to them. +@@ -3285,7 +3290,12 @@ static int oscar_sendfile_prompt(aim_ses + + /* XXX - convert the name from UTF-8 to UCS-2 if necessary, and pass the encoding to the call below */ + aim_oft_sendheader(oft_info->sess, AIM_CB_OFT_ACK, oft_info); +- gaim_xfer_start(xfer, xfer->fd, NULL, 0); ++ ++ if (xfer->fd == conn->fd && conn->io && gaim_io_get_pending_write (conn->io)) { ++ gaim_io_set_flushed_func (conn->io, (GaimIOFunc) oscar_sendfile_ready_to_xfer, xfer); ++ } else { ++ oscar_sendfile_ready_to_xfer (conn->io, xfer); ++ } + + return 0; + } +@@ -3317,7 +3327,11 @@ static int oscar_sendfile_ack(aim_sessio + gaim_input_remove(xfer->watcher); + xfer->watcher = 0; + +- gaim_xfer_start(xfer, xfer->fd, NULL, 0); ++ if (xfer->fd == conn->fd && conn->io && gaim_io_get_pending_write (conn->io)) { ++ gaim_io_set_flushed_func (conn->io, (GaimIOFunc) oscar_sendfile_ready_to_xfer, xfer); ++ } else { ++ oscar_sendfile_ready_to_xfer (conn->io, xfer); ++ } + + return 0; + } +diff -upr gaim-1.5.0/libgaim/protocols/oscar/rxqueue.c gaim-1.5.0-new/libgaim/protocols/oscar/rxqueue.c +--- gaim-1.5.0/libgaim/protocols/oscar/rxqueue.c 2004-05-05 23:41:24.000000000 -0500 ++++ gaim-1.5.0-new/libgaim/protocols/oscar/rxqueue.c 2005-09-28 11:29:24.000000000 -0500 +@@ -5,7 +5,7 @@ + */ + + #define FAIM_INTERNAL +-#include ++#include + + #ifndef _WIN32 + #include +@@ -14,43 +14,44 @@ + /* + * + */ +-faim_internal int aim_recv(int fd, void *buf, size_t count) ++faim_internal int aim_recv(aim_conn_t *conn, void *buf, size_t count) + { +- int left, cur; ++ int left, cur; + +- for (cur = 0, left = count; left; ) { +- int ret; +- +- ret = recv(fd, ((unsigned char *)buf)+cur, left, 0); ++ if (!conn->io) ++ conn->io = gaim_io_new (conn->fd); + +- /* Of course EOF is an error, only morons disagree with that. */ +- if (ret <= 0) +- return -1; +- +- cur += ret; +- left -= ret; ++ if (gaim_io_get_fd (conn->io) != conn->fd) { ++ gaim_io_destroy (conn->io); ++ conn->io = gaim_io_new (conn->fd); + } + +- return cur; ++ if (!gaim_io_is_connected (conn->io)) ++ return -1; ++ ++ if (!gaim_io_read_bytes (conn->io, buf, count)) ++ return gaim_io_is_connected (conn->io) ? 0 : -1; ++ ++ return count; + } + + /* + * Read into a byte stream. Will not read more than count, but may read + * less if there is not enough room in the stream buffer. + */ +-faim_internal int aim_bstream_recv(aim_bstream_t *bs, int fd, size_t count) ++faim_internal int aim_bstream_recv(aim_bstream_t *bs, aim_conn_t *conn, size_t count) + { + int red = 0; + +- if (!bs || (fd < 0) || (count < 0)) ++ if (!bs || (conn->fd < 0) || (count < 0)) + return -1; +- ++ + if (count > (bs->len - bs->offset)) + count = bs->len - bs->offset; /* truncate to remaining space */ + + if (count) { + +- red = aim_recv(fd, bs->data + bs->offset, count); ++ red = aim_recv(conn, bs->data + bs->offset, count); + + if (red <= 0) + return -1; +@@ -86,7 +87,7 @@ static int aim_get_command_flap(aim_sess + { + fu8_t hdr_raw[6]; + aim_bstream_t hdr; +- ++ + fr->hdrtype = AIM_FRAMETYPE_FLAP; + + /* +@@ -101,8 +102,7 @@ static int aim_get_command_flap(aim_sess + * 0x04 | Number of data bytes that follow, 2 bytes. + */ + aim_bstream_init(&hdr, hdr_raw, sizeof(hdr_raw)); +- if (aim_bstream_recv(&hdr, conn->fd, 6) < 6) { +- aim_conn_close(conn); ++ if (aim_bstream_recv(&hdr, conn, 6) < 6) { + return -1; + } + +@@ -113,10 +113,10 @@ static int aim_get_command_flap(aim_sess + * or we break. We must handle it just in case. + */ + if (aimbs_get8(&hdr) != 0x2a) { +- faimdprintf(sess, 0, "Invalid FLAP frame received on FLAP connection!"); ++ gaim_debug_misc("oscar", "Invalid FLAP frame received on FLAP connection!"); + aim_conn_close(conn); + return -1; +- } ++ } + + fr->hdr.flap.channel = aimbs_get8(&hdr); + fr->hdr.flap.seqnum = aimbs_get16(&hdr); +@@ -141,8 +141,7 @@ static int aim_get_command_rendezvous(ai + * Read rendezvous header + */ + aim_bstream_init(&hdr, hdr_raw, sizeof(hdr_raw)); +- if (aim_bstream_recv(&hdr, conn->fd, 8) < 8) { +- aim_conn_close(conn); ++ if (aim_bstream_recv(&hdr, conn, 8) < 8) { + return -1; + } + +@@ -163,7 +162,6 @@ static int aim_get_command_rendezvous(ai + */ + faim_export int aim_get_command(aim_session_t *sess, aim_conn_t *conn) + { +- aim_frame_t *fr; + int payloadlen; + + if (!sess || !conn) +@@ -172,69 +170,81 @@ faim_export int aim_get_command(aim_sess + if (conn->fd == -1) + return -1; /* it's an aim_conn_close()'d connection */ + +- if (conn->fd < 3) /* can happen when people abuse the interface */ ++ /* If stdin is closed, then zero becomes a valid fd ++ if (conn->fd < 3) + return -1; ++ */ + + if (conn->status & AIM_CONN_STATUS_INPROGRESS) + return aim_conn_completeconnect(sess, conn); + +- if (!(fr = (aim_frame_t *)calloc(sizeof(aim_frame_t), 1))) +- return -ENOMEM; ++ if (!conn->current_frame) { ++ if (!(conn->current_frame = (aim_frame_t *)calloc(sizeof(aim_frame_t), 1))) ++ return -ENOMEM; ++ ++ /* ++ * Rendezvous (client to client) connections do not speak FLAP, so this ++ * function will break on them. ++ */ ++ if (conn->type == AIM_CONN_TYPE_RENDEZVOUS) ++ payloadlen = aim_get_command_rendezvous(sess, conn, conn->current_frame); ++ else if (conn->type == AIM_CONN_TYPE_LISTENER) { ++ gaim_debug_misc("oscar", "AIM_CONN_TYPE_LISTENER on fd %d\n", conn->fd); ++ free(conn->current_frame); ++ conn->current_frame = NULL; ++ return -1; ++ } else ++ payloadlen = aim_get_command_flap(sess, conn, conn->current_frame); + +- /* +- * Rendezvous (client to client) connections do not speak FLAP, so this +- * function will break on them. +- */ +- if (conn->type == AIM_CONN_TYPE_RENDEZVOUS) +- payloadlen = aim_get_command_rendezvous(sess, conn, fr); +- else if (conn->type == AIM_CONN_TYPE_LISTENER) { +- faimdprintf(sess, 0, "AIM_CONN_TYPE_LISTENER on fd %d\n", conn->fd); +- free(fr); +- return -1; +- } else +- payloadlen = aim_get_command_flap(sess, conn, fr); ++ if (payloadlen < 0) { ++ free(conn->current_frame); ++ conn->current_frame = NULL; ++ return -1; ++ } + +- if (payloadlen < 0) { +- free(fr); +- return -1; +- } ++ conn->current_payload_len = payloadlen; ++ } else ++ payloadlen = conn->current_payload_len; + +- if (payloadlen > 0) { ++ if (conn->current_payload_len > 0) { + fu8_t *payload = NULL; + + if (!(payload = (fu8_t *) malloc(payloadlen))) { +- aim_frame_destroy(fr); + return -1; + } + +- aim_bstream_init(&fr->data, payload, payloadlen); ++ aim_bstream_init(&conn->current_frame->data, payload, payloadlen); + + /* read the payload */ +- if (aim_bstream_recv(&fr->data, conn->fd, payloadlen) < payloadlen) { +- aim_frame_destroy(fr); /* free's payload */ +- aim_conn_close(conn); ++ if (aim_bstream_recv(&conn->current_frame->data, conn, payloadlen) < payloadlen) { ++ free (payload); + return -1; + } +- } else +- aim_bstream_init(&fr->data, NULL, 0); ++ } else if (conn->current_payload_len == 0) ++ aim_bstream_init(&conn->current_frame->data, NULL, 0); + +- aim_bstream_rewind(&fr->data); ++ if (conn->current_payload_len >= 0) { ++ aim_bstream_rewind(&conn->current_frame->data); + +- fr->conn = conn; ++ conn->current_frame->conn = conn; + +- /* Enqueue this puppy */ +- fr->next = NULL; /* this will always be at the bottom */ +- if (sess->queue_incoming == NULL) +- sess->queue_incoming = fr; +- else { +- aim_frame_t *cur; +- for (cur = sess->queue_incoming; cur->next; cur = cur->next); +- cur->next = fr; +- } ++ /* Enqueue this puppy */ ++ conn->current_frame->next = NULL; /* this will always be at the bottom */ ++ if (sess->queue_incoming == NULL) ++ sess->queue_incoming = conn->current_frame; ++ else { ++ aim_frame_t *cur; ++ for (cur = sess->queue_incoming; cur->next; cur = cur->next); ++ cur->next = conn->current_frame; ++ } + +- fr->conn->lastactivity = time(NULL); ++ conn->current_frame->conn->lastactivity = time(NULL); + +- return 0; ++ conn->current_frame = NULL; ++ return 0; ++ } ++ ++ return -1; + } + + /* +@@ -270,7 +280,7 @@ faim_internal void aim_rxqueue_cleanbyco + for (currx = sess->queue_incoming; currx; currx = currx->next) { + if ((!currx->handled) && (currx->conn == conn)) + currx->handled = 1; +- } ++ } + + return; + } +diff -upr gaim-1.5.0/libgaim/protocols/oscar/txqueue.c gaim-1.5.0-new/libgaim/protocols/oscar/txqueue.c +--- gaim-1.5.0/libgaim/protocols/oscar/txqueue.c 2004-07-06 02:00:32.000000000 -0500 ++++ gaim-1.5.0-new/libgaim/protocols/oscar/txqueue.c 2005-09-28 11:29:24.000000000 -0500 +@@ -192,25 +192,22 @@ faim_internal int aim_tx_enqueue(aim_ses + return (*sess->tx_enqueue)(sess, fr); + } + +-static int aim_send(int fd, const void *buf, size_t count) ++static int aim_send(aim_conn_t *conn, const void *buf, size_t count) + { + int left, cur; + +- for (cur = 0, left = count; left; ) { +- int ret; ++ if (!conn->io) ++ conn->io = gaim_io_new (conn->fd); + +- ret = send(fd, ((unsigned char *)buf)+cur, left, 0); +- +- if (ret == -1) +- return -1; +- else if (ret == 0) +- return cur; +- +- cur += ret; +- left -= ret; ++ if (gaim_io_get_fd (conn->io) != conn->fd) { ++ gaim_io_destroy (conn->io); ++ conn->io = gaim_io_new (conn->fd); + } + +- return cur; ++ if (!gaim_io_write_bytes (conn->io, buf, count)) ++ return -1; ++ ++ return count; + } + + static int aim_bstream_send(aim_bstream_t *bs, aim_conn_t *conn, size_t count) +@@ -239,7 +236,7 @@ static int aim_bstream_send(aim_bstream_ + while (count - wrote > 1024) { + int ret; + +- ret = aim_send(conn->fd, bs->data + bs->offset + wrote, 1024); ++ ret = aim_send(conn, bs->data + bs->offset + wrote, 1024); + if (ret > 0) + wrote += ret; + if (ret < 0) +@@ -250,7 +247,7 @@ static int aim_bstream_send(aim_bstream_ + } + + if (count - wrote) { +- wrote = wrote + aim_send(conn->fd, bs->data + bs->offset + wrote, count - wrote); ++ wrote = wrote + aim_send(conn, bs->data + bs->offset + wrote, count - wrote); + } + } + diff --git a/pidgin-nonblock-common.patch b/pidgin-nonblock-common.patch new file mode 100644 index 0000000..19152f0 --- /dev/null +++ b/pidgin-nonblock-common.patch @@ -0,0 +1,983 @@ +diff -uprN gaim-1.5.0-old/libpurple/plugins/ssl/ssl-gnutls.c gaim-1.5.0-new/libpurple/plugins/ssl/ssl-gnutls.c +--- gaim-1.5.0-old/libpurple/plugins/ssl/ssl-gnutls.c 2004-09-03 16:34:16.000000000 -0500 ++++ gaim-1.5.0-new/libpurple/plugins/ssl/ssl-gnutls.c 2005-11-12 21:42:43.000000000 -0600 +@@ -131,8 +131,6 @@ ssl_gnutls_close(PurpleSslConnection *gsc) + if(!gnutls_data) + return; + +- gnutls_bye(gnutls_data->session, GNUTLS_SHUT_RDWR); +- + gnutls_deinit(gnutls_data->session); + + g_free(gnutls_data); +@@ -160,6 +158,22 @@ ssl_gnutls_read(PurpleSslConnection *gsc, + } + + static size_t ++ssl_gnutls_read_nonblock(PurpleSslConnection *gsc, void *data, size_t len) ++{ ++ PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc); ++ int s; ++ ++ s = gnutls_record_recv(gnutls_data->session, data, len); ++ ++ if (s == GNUTLS_E_AGAIN) ++ s = PURPLE_SSL_IO_AGAIN; ++ else if (s == GNUTLS_E_INTERRUPTED) ++ s = PURPLE_SSL_IO_INTERRUPTED; ++ ++ return s; ++} ++ ++static size_t + ssl_gnutls_write(PurpleSslConnection *gsc, const void *data, size_t len) + { + PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc); +@@ -171,6 +185,23 @@ ssl_gnutls_write(PurpleSslConnection *gsc, + return s; + } + ++static size_t ++ssl_gnutls_write_nonblock(PurpleSslConnection *gsc, const void *data, size_t len) ++{ ++ PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc); ++ size_t s = 0; ++ ++ if(gnutls_data) ++ s = gnutls_record_send(gnutls_data->session, data, len); ++ ++ if (s == GNUTLS_E_AGAIN) ++ s = PURPLE_SSL_IO_AGAIN; ++ else if (s == GNUTLS_E_INTERRUPTED) ++ s = PURPLE_SSL_IO_INTERRUPTED; ++ ++ return s; ++} ++ + static PurpleSslOps ssl_ops = + { + ssl_gnutls_init, +@@ -178,7 +209,9 @@ static PurpleSslOps ssl_ops = + ssl_gnutls_connect, + ssl_gnutls_close, + ssl_gnutls_read, +- ssl_gnutls_write, ++ ssl_gnutls_read_nonblock, ++ ssl_gnutls_write, ++ ssl_gnutls_write_nonblock, + + /* padding */ + NULL, +diff -uprN gaim-1.5.0-old/libpurple/plugins/ssl/ssl-nss.c gaim-1.5.0-new/libpurple/plugins/ssl/ssl-nss.c +--- gaim-1.5.0-old/libpurple/plugins/ssl/ssl-nss.c 2005-01-16 18:32:26.000000000 -0600 ++++ gaim-1.5.0-new/libpurple/plugins/ssl/ssl-nss.c 2005-11-12 21:42:23.000000000 -0600 +@@ -269,6 +269,8 @@ static PurpleSslOps ssl_ops = + ssl_nss_connect, + ssl_nss_close, + ssl_nss_read, ++ ssl_nss_read, ++ ssl_nss_write, + ssl_nss_write, + + /* padding */ +diff -uprN gaim-1.5.0-old/libpurple/purple-fifo.c gaim-1.5.0-new/libpurple/purple-fifo.c +--- gaim-1.5.0-old/libpurple/purple-fifo.c 1969-12-31 18:00:00.000000000 -0600 ++++ gaim-1.5.0-new/libpurple/purple-fifo.c 2005-11-12 21:42:23.000000000 -0600 +@@ -0,0 +1,232 @@ ++/* ++ * @file purple-fifo.c A FIFO byte queue. ++ * @ingroup core ++ * ++ * Pidgin is the legal property of its developers, whose names are too numerous ++ * to list here. Please refer to the COPYRIGHT file distributed with this ++ * source distribution. ++ * ++ * 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 ++ */ ++#include "internal.h" ++ ++#define BUFFER_SIZE 256 ++ ++typedef struct ++{ ++ GList *buffer_list; ++ GList *enqueue_buffer; ++ gint enqueue_pos; ++ GList *dequeue_buffer; ++ gint dequeue_pos; ++ ++ gint total_used; ++} ++PurpleFifo; ++ ++PurpleFifo * ++purple_fifo_new (void) ++{ ++ return g_new0 (PurpleFifo, 1); ++} ++ ++void ++purple_fifo_destroy (PurpleFifo *fifo) ++{ ++ GList *l; ++ ++ for (l = fifo->buffer_list; l; l = g_list_next (l)) ++ g_free (l->data); ++ ++ g_list_free (fifo->buffer_list); ++} ++ ++gint ++purple_fifo_get_used (PurpleFifo *fifo) ++{ ++ return fifo->total_used; ++} ++ ++static void ++ensure_buffers (PurpleFifo *fifo) ++{ ++ if (!fifo->buffer_list) ++ { ++ fifo->buffer_list = g_list_append (NULL, g_malloc (BUFFER_SIZE)); ++ fifo->enqueue_buffer = fifo->buffer_list; ++ fifo->dequeue_buffer = fifo->buffer_list; ++ ++ fifo->buffer_list->data = g_malloc (BUFFER_SIZE); ++ } ++} ++ ++static void ++enqueue_next_buffer (PurpleFifo *fifo) ++{ ++ g_list_append (fifo->enqueue_buffer, g_malloc (BUFFER_SIZE)); ++ fifo->enqueue_buffer = g_list_next (fifo->enqueue_buffer); ++ fifo->enqueue_pos = 0; ++} ++ ++static void ++dequeue_next_buffer (PurpleFifo *fifo) ++{ ++ g_free (fifo->dequeue_buffer->data); ++ fifo->dequeue_buffer = g_list_delete_link (fifo->dequeue_buffer, fifo->dequeue_buffer); ++ ++ fifo->buffer_list = fifo->dequeue_buffer; ++ if (!fifo->buffer_list) ++ fifo->enqueue_buffer = NULL; ++ ++ fifo->dequeue_pos = 0; ++} ++ ++void ++purple_fifo_enqueue (PurpleFifo *fifo, gconstpointer libpurple, gint n) ++{ ++ gint in_pos; ++ ++ ensure_buffers (fifo); ++ ++ for (in_pos = 0; in_pos < n; ) ++ { ++ gint n_copied = MIN (BUFFER_SIZE - fifo->enqueue_pos, n - in_pos); ++ ++ memcpy (((guint8 *) fifo->enqueue_buffer->data) + fifo->enqueue_pos, ((const guint8 *) libpurple) + in_pos, n_copied); ++ ++ fifo->enqueue_pos += n_copied; ++ in_pos += n_copied; ++ ++ if (fifo->enqueue_pos == BUFFER_SIZE) ++ enqueue_next_buffer (fifo); ++ } ++ ++ fifo->total_used += n; ++} ++ ++gboolean ++purple_fifo_dequeue (PurpleFifo *fifo, gpointer dest, gint n) ++{ ++ gint out_pos; ++ ++ if (n > fifo->total_used) ++ return FALSE; ++ ++ for (out_pos = 0; out_pos < n; ) ++ { ++ gint n_copied = MIN (BUFFER_SIZE - fifo->dequeue_pos, n - out_pos); ++ ++ if (dest) ++ memcpy (((guint8 *) dest) + out_pos, ++ ((guint8 *) fifo->dequeue_buffer->data) + fifo->dequeue_pos, ++ n_copied); ++ ++ fifo->dequeue_pos += n_copied; ++ out_pos += n_copied; ++ ++ if (fifo->dequeue_pos == BUFFER_SIZE) ++ dequeue_next_buffer (fifo); ++ } ++ ++ fifo->total_used -= n; ++ return TRUE; ++} ++ ++gboolean ++purple_fifo_dequeue_line (PurpleFifo *fifo, gchar **dest) ++{ ++ gchar *line; ++ gboolean have_cr = FALSE; ++ gboolean have_crlf = FALSE; ++ GList *buffer_l; ++ gint pos; ++ gint n; ++ ++ buffer_l = fifo->dequeue_buffer; ++ n = 0; ++ ++ for (pos = fifo->dequeue_pos; n < fifo->total_used && !have_crlf; pos++, n++) ++ { ++ guint8 *p = ((guint8 *) buffer_l->data) + fifo->dequeue_pos; ++ guint8 c = *p; ++ ++ if (c == '\r') ++ { ++ have_cr = TRUE; ++ have_crlf = FALSE; ++ } ++ else if (c == '\n' && have_cr) ++ { ++ have_crlf = TRUE; ++ } ++ ++ if (pos == BUFFER_SIZE) ++ { ++ buffer_l = g_list_next (buffer_l); ++ pos = 0; ++ } ++ } ++ ++ if (!have_crlf) ++ return FALSE; ++ ++ line = g_malloc (n + 1); ++ if (!purple_fifo_dequeue (fifo, line, n)) ++ { ++ /* Paranoid check; can't happen in practice */ ++ g_free (line); ++ return FALSE; ++ } ++ ++ *(line + n) = '\0'; ++ *dest = line; ++ ++ return TRUE; ++} ++ ++gboolean ++purple_fifo_peek (PurpleFifo *fifo, gpointer dest, gint n) ++{ ++ GList *dequeue_buffer; ++ gint dequeue_pos; ++ gint out_pos; ++ ++ if (n > fifo->total_used) ++ return FALSE; ++ ++ dequeue_buffer = fifo->dequeue_buffer; ++ dequeue_pos = fifo->dequeue_pos; ++ ++ for (out_pos = 0; out_pos < n; ) ++ { ++ gint n_copied = MIN (BUFFER_SIZE - dequeue_pos, n - out_pos); ++ ++ if (dest) ++ memcpy (((guint8 *) dest) + out_pos, ++ ((guint8 *) dequeue_buffer->data) + dequeue_pos, ++ n_copied); ++ ++ dequeue_pos += n_copied; ++ out_pos += n_copied; ++ ++ if (dequeue_pos == BUFFER_SIZE) ++ { ++ dequeue_buffer = g_list_next (dequeue_buffer); ++ dequeue_pos = 0; ++ } ++ } ++ ++ return TRUE; ++} +diff -uprN gaim-1.5.0-old/libpurple/purple-fifo.h gaim-1.5.0-new/libpurple/purple-fifo.h +--- gaim-1.5.0-old/libpurple/purple-fifo.h 1969-12-31 18:00:00.000000000 -0600 ++++ gaim-1.5.0-new/libpurple/purple-fifo.h 2005-11-12 21:42:23.000000000 -0600 +@@ -0,0 +1,54 @@ ++/** ++ * @file purple-fifo.h A FIFO byte queue. ++ * @ingroup core ++ * ++ * Pidgin is the legal property of its developers, whose names are too numerous ++ * to list here. Please refer to the COPYRIGHT file distributed with this ++ * source distribution. ++ * ++ * 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 ++ */ ++ ++#ifndef _purple_fifo_H_ ++#define _purple_fifo_H_ ++ ++#include ++ ++G_BEGIN_DECLS ++ ++typedef struct ++{ ++ GList *buffer_list; ++ GList *enqueue_buffer; ++ gint enqueue_pos; ++ GList *dequeue_buffer; ++ gint dequeue_pos; ++} ++PurpleFifo; ++ ++PurpleFifo *purple_fifo_new (void); ++void purple_fifo_destroy (PurpleFifo *fifo); ++ ++gint purple_fifo_get_used (PurpleFifo *fifo); ++ ++void purple_fifo_enqueue (PurpleFifo *fifo, gconstpointer libpurple, gint n); ++gboolean purple_fifo_dequeue (PurpleFifo *fifo, gpointer dest, gint n); ++gboolean purple_fifo_dequeue_line (PurpleFifo *fifo, gchar **dest); ++ ++gboolean purple_fifo_peek (PurpleFifo *fifo, gpointer dest, gint n); ++ ++G_END_DECLS ++ ++#endif /* _purple_fifo_H_ */ +diff -uprN gaim-1.5.0-old/libpurple/purple-io.c gaim-1.5.0-new/libpurple/purple-io.c +--- gaim-1.5.0-old/libpurple/purple-io.c 1969-12-31 18:00:00.000000000 -0600 ++++ gaim-1.5.0-new/libpurple/purple-io.c 2005-11-12 21:42:23.000000000 -0600 +@@ -0,0 +1,391 @@ ++/* ++ * @file purple-io.c Buffering I/O layer. ++ * @ingroup core ++ * ++ * Pidgin is the legal property of its developers, whose names are too numerous ++ * to list here. Please refer to the COPYRIGHT file distributed with this ++ * source distribution. ++ * ++ * 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 ++ */ ++ ++#include "internal.h" ++#include "eventloop.h" ++#include "purple-io.h" ++ ++#define OPERATION_MAX_BYTES 4096 ++#define WRITE_LOW_WATER 512 ++ ++static void update_watches (PurpleIO *io); ++ ++static gboolean ++can_read (PurpleIO *io) ++{ ++ fd_set rfds; ++ struct timeval tv; ++ int retval; ++ ++ FD_ZERO(&rfds); ++ FD_SET(io->fd, &rfds); ++ ++ tv.tv_sec = 0; ++ tv.tv_usec = 1; ++ ++ retval = select (io->fd + 1, &rfds, NULL, NULL, &tv); ++ ++ return retval ? TRUE : FALSE; ++} ++ ++static gint ++try_read (PurpleIO *io, gint max_read, gint *read_errno) ++{ ++ guint8 buf [OPERATION_MAX_BYTES]; ++ glong flags; ++ gint n_read; ++ ++ /* Do a non-blocking read */ ++ flags = fcntl (io->fd, F_GETFL); ++ fcntl (io->fd, F_SETFL, flags | O_NONBLOCK); ++ ++ if (io->gsc) { ++ n_read = purple_ssl_read_nonblock (io->gsc, buf, MIN (max_read, OPERATION_MAX_BYTES)); ++ ++ if (read_errno) { ++ if (n_read == PURPLE_SSL_IO_AGAIN) ++ *read_errno = EAGAIN; ++ else if (n_read == PURPLE_SSL_IO_INTERRUPTED) ++ *read_errno = EINTR; ++ else ++ *read_errno = 0; ++ } ++ ++ if (n_read < 0) ++ n_read = 0; ++ } else { ++ n_read = read (io->fd, buf, MIN (max_read, OPERATION_MAX_BYTES)); ++ if (read_errno) ++ *read_errno = errno; ++ } ++ ++ fcntl (io->fd, F_SETFL, flags); ++ ++ if (n_read > 0) { ++ /* Got some data */ ++ purple_fifo_enqueue (io->read_fifo, buf, n_read); ++ } ++ ++ return n_read; ++} ++ ++static void ++read_nonblock (PurpleIO *io, gint max_read) ++{ ++ gint read_errno; ++ ++ if (io->got_eof) ++ return; ++ ++ if (max_read <= purple_fifo_get_used (io->read_fifo)) ++ return; ++ ++ max_read -= purple_fifo_get_used (io->read_fifo); ++ ++ if (can_read (io) && try_read (io, max_read, &read_errno) < 1 && read_errno != EINTR) ++ { ++ /* Disconnected */ ++ io->got_eof = TRUE; ++ update_watches (io); ++ ++ if (io->eof_func) ++ io->eof_func (io, io->eof_func_data); ++ } ++} ++ ++static void ++read_cb (gpointer data, gint source, PurpleInputCondition condition) ++{ ++ PurpleIO *io = data; ++ gint n_read; ++ gint read_errno; ++ ++ n_read = try_read (io, OPERATION_MAX_BYTES, &read_errno); ++ ++ /* If interrupted by signal, just retry later */ ++ if (n_read < 0 && read_errno == EINTR) ++ return; ++ ++ /* If we got 0 bytes or an error that's not EINTR, the connection was closed */ ++ if (n_read < 1) { ++ io->got_eof = TRUE; ++ update_watches (io); ++ ++ if (io->eof_func) ++ io->eof_func (io, io->eof_func_data); ++ ++ return; ++ } ++ ++ if (io->read_func) ++ io->read_func (io, io->read_func_data); ++ ++ update_watches (io); ++} ++ ++static void ++write_cb (gpointer data, gint source, PurpleInputCondition condition) ++{ ++ PurpleIO *io = data; ++ guint8 buf [OPERATION_MAX_BYTES]; ++ gint n_written; ++ glong flags; ++ ++ n_written = purple_fifo_get_used (io->write_fifo); ++ n_written = MIN (OPERATION_MAX_BYTES, n_written); ++ ++ /* Paranoid: Shouldn't happen */ ++ if (n_written < 1) ++ return; ++ ++ purple_fifo_peek (io->write_fifo, buf, n_written); ++ ++ flags = fcntl (io->fd, F_GETFL); ++ fcntl (io->fd, F_SETFL, flags | O_NONBLOCK); ++ ++ if (io->gsc) { ++ n_written = purple_ssl_write_nonblock (io->gsc, buf, n_written); ++ } else { ++ n_written = write (io->fd, buf, n_written); ++ } ++ ++ fcntl (io->fd, F_SETFL, flags); ++ ++ if (n_written < 0) ++ io->got_eof = TRUE; ++ ++ if (n_written < 1) ++ return; ++ ++ /* Drop written data from buffer */ ++ purple_fifo_dequeue (io->write_fifo, NULL, n_written); ++ ++ if (io->flushed_func && ++ purple_fifo_get_used (io->write_fifo) == 0) ++ io->flushed_func (io, io->flushed_func_data); ++ ++ if (io->write_func && ++ purple_fifo_get_used (io->write_fifo) < WRITE_LOW_WATER) ++ io->write_func (io, io->write_func_data); ++ ++ update_watches (io); ++} ++ ++static void ++update_watches (PurpleIO *io) ++{ ++ gboolean want_read_watch = FALSE; ++ gboolean want_write_watch = FALSE; ++ ++ if (!io->got_eof) { ++ if (io->read_func) ++ want_read_watch = TRUE; ++ ++ if (purple_fifo_get_used (io->write_fifo)) ++ want_write_watch = TRUE; ++ } ++ ++ if (want_read_watch && !io->read_watch_id) { ++ io->read_watch_id = purple_input_add (io->fd, PURPLE_INPUT_READ, read_cb, io); ++ } else if (!want_read_watch && io->read_watch_id) { ++ purple_input_remove (io->read_watch_id); ++ io->read_watch_id = 0; ++ } ++ ++ if (want_write_watch && !io->write_watch_id) { ++ io->write_watch_id = purple_input_add (io->fd, PURPLE_INPUT_WRITE, write_cb, io); ++ } else if (!want_write_watch && io->write_watch_id) { ++ purple_input_remove (io->write_watch_id); ++ io->write_watch_id = 0; ++ } ++} ++ ++PurpleIO * ++purple_io_new (gint fd) ++{ ++ PurpleIO *io; ++ ++ io = g_new0 (PurpleIO, 1); ++ ++ io->fd = fd; ++ io->read_fifo = purple_fifo_new (); ++ io->write_fifo = purple_fifo_new (); ++ ++ return io; ++} ++ ++PurpleIO * ++purple_io_new_ssl (PurpleSslConnection *gsc) ++{ ++ PurpleIO *io; ++ ++ io = g_new0 (PurpleIO, 1); ++ ++ io->gsc = gsc; ++ io->fd = gsc->fd; ++ io->read_fifo = purple_fifo_new (); ++ io->write_fifo = purple_fifo_new (); ++ ++ return io; ++} ++ ++void ++purple_io_destroy (PurpleIO *io) ++{ ++#if 0 ++ if (purple_fifo_get_used (io->write_fifo) > 0) ++ g_print ("Throwing away outbound data!\n"); ++#endif ++ ++ if (io->read_watch_id) ++ purple_input_remove (io->read_watch_id); ++ if (io->write_watch_id) ++ purple_input_remove (io->write_watch_id); ++ ++ purple_fifo_destroy (io->read_fifo); ++ purple_fifo_destroy (io->write_fifo); ++ ++ if (io->gsc) ++ purple_ssl_close (io->gsc); ++ else ++ close (io->fd); ++ ++ g_free (io); ++} ++ ++gint ++purple_io_get_fd (PurpleIO *io) ++{ ++ return io->fd; ++} ++ ++PurpleSslConnection * ++purple_io_get_ssl_connection (PurpleIO *io) ++{ ++ return io->gsc; ++} ++ ++gboolean ++purple_io_is_connected (PurpleIO *io) ++{ ++ return !io->got_eof; ++} ++ ++void ++purple_io_set_read_func (PurpleIO *io, PurpleIOFunc func, gpointer data) ++{ ++ io->read_func = func; ++ io->read_func_data = data; ++ ++ update_watches (io); ++} ++ ++void ++purple_io_set_write_func (PurpleIO *io, PurpleIOFunc func, gpointer data) ++{ ++ io->write_func = func; ++ io->write_func_data = data; ++ ++ update_watches (io); ++} ++ ++void ++purple_io_set_eof_func (PurpleIO *io, PurpleIOFunc func, gpointer data) ++{ ++ io->eof_func = func; ++ io->eof_func_data = data; ++ ++ update_watches (io); ++} ++ ++void ++purple_io_set_flushed_func (PurpleIO *io, PurpleIOFunc func, gpointer data) ++{ ++ io->flushed_func = func; ++ io->flushed_func_data = data; ++ ++ update_watches (io); ++} ++ ++gboolean ++purple_io_write_bytes (PurpleIO *io, gconstpointer libpurple, gint n_bytes) ++{ ++ if (io->got_eof) ++ return FALSE; ++ ++ purple_fifo_enqueue (io->write_fifo, libpurple, n_bytes); ++ ++ update_watches (io); ++ return TRUE; ++} ++ ++gboolean ++purple_io_write_line (PurpleIO *io, const gchar *line) ++{ ++ if (io->got_eof) ++ return FALSE; ++ ++ purple_fifo_enqueue (io->write_fifo, line, strlen (line)); ++ purple_fifo_enqueue (io->write_fifo, "\r\n", 2); ++ ++ update_watches (io); ++ return TRUE; ++} ++ ++gboolean ++purple_io_read_bytes (PurpleIO *io, gpointer dest, gint n_bytes) ++{ ++ gboolean result; ++ ++ read_nonblock (io, n_bytes); ++ ++ result = purple_fifo_dequeue (io->read_fifo, dest, n_bytes); ++ ++ update_watches (io); ++ return result; ++} ++ ++gboolean ++purple_io_read_line (PurpleIO *io, gchar **line) ++{ ++ gboolean result; ++ ++ read_nonblock (io, 65536); ++ ++ result = purple_fifo_dequeue_line (io->read_fifo, line); ++ ++ update_watches (io); ++ return result; ++} ++ ++gint ++purple_io_get_pending_read (PurpleIO *io) ++{ ++ return purple_fifo_get_used (io->read_fifo); ++} ++ ++gint ++purple_io_get_pending_write (PurpleIO *io) ++{ ++ return purple_fifo_get_used (io->write_fifo); ++} +diff -uprN gaim-1.5.0-old/libpurple/purple-io.h gaim-1.5.0-new/libpurple/purple-io.h +--- gaim-1.5.0-old/libpurple/purple-io.h 1969-12-31 18:00:00.000000000 -0600 ++++ gaim-1.5.0-new/libpurple/purple-io.h 2005-11-12 21:42:23.000000000 -0600 +@@ -0,0 +1,87 @@ ++/** ++ * @file purple-io.h Buffering I/O layer. ++ * @ingroup core ++ * ++ * Pidgin is the legal property of its developers, whose names are too numerous ++ * to list here. Please refer to the COPYRIGHT file distributed with this ++ * source distribution. ++ * ++ * 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 ++ */ ++ ++#ifndef _PURPLE_IO_H_ ++#define _PURPLE_IO_H_ ++ ++#include "purple-fifo.h" ++#include "sslconn.h" ++ ++G_BEGIN_DECLS ++ ++typedef struct PurpleIO PurpleIO; ++ ++typedef void (*PurpleIOFunc) (PurpleIO *io, gpointer data); ++ ++struct PurpleIO ++{ ++ gint fd; ++ PurpleSslConnection *gsc; ++ ++ guint got_eof : 1; ++ ++ PurpleFifo *read_fifo; ++ PurpleFifo *write_fifo; ++ ++ guint read_watch_id; ++ guint write_watch_id; ++ ++ /* Callback invoked when input buffer grows */ ++ PurpleIOFunc read_func; ++ gpointer read_func_data; ++ ++ /* Callback invoked when output buffer shrinks (sufficiently) */ ++ PurpleIOFunc write_func; ++ gpointer write_func_data; ++ ++ /* Callback invoked when connection drops */ ++ PurpleIOFunc eof_func; ++ gpointer eof_func_data; ++ ++ /* Callback invoked when output buffer empty */ ++ PurpleIOFunc flushed_func; ++ gpointer flushed_func_data; ++}; ++ ++PurpleIO *purple_io_new (gint fd); ++PurpleIO *purple_io_new_ssl (PurpleSslConnection *gsc); ++void purple_io_destroy (PurpleIO *io); ++ ++gint purple_io_get_fd (PurpleIO *io); ++PurpleSslConnection *purple_io_get_ssl_connection (PurpleIO *io); ++gboolean purple_io_is_connected (PurpleIO *io); ++ ++void purple_io_set_read_func (PurpleIO *io, PurpleIOFunc func, gpointer data); ++void purple_io_set_write_func (PurpleIO *io, PurpleIOFunc func, gpointer data); ++void purple_io_set_eof_func (PurpleIO *io, PurpleIOFunc func, gpointer data); ++void purple_io_set_flushed_func (PurpleIO *io, PurpleIOFunc func, gpointer data); ++ ++gboolean purple_io_write_bytes (PurpleIO *io, gconstpointer libpurple, gint n_bytes); ++gboolean purple_io_write_line (PurpleIO *io, const gchar *line); ++ ++gboolean purple_io_read_bytes (PurpleIO *io, gpointer dest, gint n_bytes); ++gboolean purple_io_read_line (PurpleIO *io, gchar **line); ++ ++G_END_DECLS ++ ++#endif /* _PURPLE_IO_H_ */ +diff -uprN gaim-1.5.0-old/libpurple/sslconn.c gaim-1.5.0-new/libpurple/sslconn.c +--- gaim-1.5.0-old/libpurple/sslconn.c 2004-01-09 22:04:56.000000000 -0600 ++++ gaim-1.5.0-new/libpurple/sslconn.c 2005-11-12 21:42:23.000000000 -0600 +@@ -209,6 +209,27 @@ purple_ssl_read(PurpleSslConnection *gsc, vo + } + + size_t ++purple_ssl_read_nonblock(PurpleSslConnection *gsc, void *data, size_t len) ++{ ++ PurpleSslOps *ops; ++ ++ g_return_val_if_fail(gsc != NULL, 0); ++ g_return_val_if_fail(data != NULL, 0); ++ g_return_val_if_fail(len > 0, 0); ++ ++ ops = purple_ssl_get_ops(); ++ ++ if (ops != NULL) { ++ if (ops->read_nonblock != NULL) ++ return (ops->read_nonblock)(gsc, data, len); ++ else if (ops->read != NULL) ++ return (ops->read)(gsc, data, len); ++ } ++ ++ return 0; ++} ++ ++size_t + purple_ssl_write(PurpleSslConnection *gsc, const void *data, size_t len) + { + PurpleSslOps *ops; +@@ -225,6 +246,27 @@ purple_ssl_write(PurpleSslConnection *gsc, c + return 0; + } + ++size_t ++purple_ssl_write_nonblock(PurpleSslConnection *gsc, const void *data, size_t len) ++{ ++ PurpleSslOps *ops; ++ ++ g_return_val_if_fail(gsc != NULL, 0); ++ g_return_val_if_fail(data != NULL, 0); ++ g_return_val_if_fail(len > 0, 0); ++ ++ ops = purple_ssl_get_ops(); ++ ++ if (ops != NULL) { ++ if (ops->write_nonblock != NULL) ++ return (ops->write_nonblock)(gsc, data, len); ++ else if (ops->write != NULL) ++ return (ops->write)(gsc, data, len); ++ } ++ ++ return 0; ++} ++ + void + purple_ssl_set_ops(PurpleSslOps *ops) + { +diff -uprN gaim-1.5.0-old/libpurple/sslconn.h gaim-1.5.0-new/libpurple/sslconn.h +--- gaim-1.5.0-old/libpurple/sslconn.h 2004-08-08 00:37:58.000000000 -0500 ++++ gaim-1.5.0-new/libpurple/sslconn.h 2005-11-12 21:42:23.000000000 -0600 +@@ -35,6 +35,12 @@ typedef enum + PURPLE_SSL_CONNECT_FAILED = 2 + } PurpleSslErrorType; + ++typedef enum ++{ ++ PURPLE_SSL_IO_INTERRUPTED = -1, ++ PURPLE_SSL_IO_AGAIN = -2 ++} PurpleSslIOErrorType; ++ + typedef struct _PurpleSslConnection PurpleSslConnection; + + typedef void (*PurpleSslInputFunction)(gpointer, PurpleSslConnection *, +@@ -70,7 +76,9 @@ typedef struct + PurpleInputFunction connect_cb; + void (*close)(PurpleSslConnection *gsc); + size_t (*read)(PurpleSslConnection *gsc, void *data, size_t len); ++ size_t (*read_nonblock)(PurpleSslConnection *gsc, void *data, size_t len); + size_t (*write)(PurpleSslConnection *gsc, const void *data, size_t len); ++ size_t (*write_nonblock)(PurpleSslConnection *gsc, const void *data, size_t len); + + } PurpleSslOps; + +@@ -152,6 +160,17 @@ void purple_ssl_close(PurpleSslConnection *g + size_t purple_ssl_read(PurpleSslConnection *gsc, void *buffer, size_t len); + + /** ++ * Reads data from an SSL connection without blocking. ++ * ++ * @param gsc The SSL connection handle. ++ * @param buffer The destination buffer. ++ * @param len The maximum number of bytes to read. ++ * ++ * @return The number of bytes read. ++ */ ++size_t purple_ssl_read_nonblock(PurpleSslConnection *gsc, void *buffer, size_t len); ++ ++/** + * Writes data to an SSL connection. + * + * @param gsc The SSL connection handle. +@@ -162,6 +181,17 @@ size_t purple_ssl_read(PurpleSslConnection * + */ + size_t purple_ssl_write(PurpleSslConnection *gsc, const void *buffer, size_t len); + ++/** ++ * Writes data to an SSL connection without blocking. ++ * ++ * @param gsc The SSL connection handle. ++ * @param buffer The buffer to write. ++ * @param len The length of the data to write. ++ * ++ * @return The number of bytes written. ++ */ ++size_t purple_ssl_write_nonblock(PurpleSslConnection *gsc, const void *buffer, size_t len); ++ + /*@}*/ + + /**************************************************************************/ diff --git a/pidgin-nonblock-common2.patch b/pidgin-nonblock-common2.patch new file mode 100644 index 0000000..4309d01 --- /dev/null +++ b/pidgin-nonblock-common2.patch @@ -0,0 +1,21 @@ +diff -ruN gaim-2.0.0beta6.orig/libgaim/Makefile.am gaim-2.0.0beta6/libgaim/Makefile.am +--- gaim-2.0.0beta6.orig/libpurple/Makefile.am 2007-01-19 04:28:24.000000000 +0000 ++++ gaim-2.0.0beta6/libpurple/Makefile.am 2007-02-19 17:41:07.000000000 +0000 +@@ -40,6 +40,8 @@ + desktopitem.c \ + eventloop.c \ + ft.c \ ++ purple-fifo.c \ ++ purple-io.c \ + idle.c \ + imgstore.c \ + log.c \ +@@ -89,6 +91,8 @@ + desktopitem.h \ + eventloop.h \ + ft.h \ ++ purple-fifo.h \ ++ purple-io.h \ + gaim-compat.h \ + idle.h \ + imgstore.h \ diff --git a/pidgin-nonblock-gwim.patch b/pidgin-nonblock-gwim.patch new file mode 100644 index 0000000..b86b6e9 --- /dev/null +++ b/pidgin-nonblock-gwim.patch @@ -0,0 +1,87 @@ +diff -uprN gaim-1.5.0-clean/libpurple/protocols/novell/nmconn.c gaim-1.5.0-new-files/libpurple/protocols/novell/nmconn.c +--- gaim-1.5.0-clean/libpurple/protocols/novell/nmconn.c 2005-03-06 17:10:36.000000000 -0500 ++++ gaim-1.5.0-new-files/libpurple/protocols/novell/nmconn.c 2005-10-05 14:57:03.000000000 -0400 +@@ -191,6 +191,12 @@ void nm_release_conn(NMConn *conn) + g_free(conn->ssl_conn); + conn->ssl_conn = NULL; + } ++ ++ if (conn->io) { ++ purple_io_destroy (conn->io); ++ conn->io = NULL; ++ } ++ + g_free(conn->addr); + conn->addr = NULL; + g_free(conn); +@@ -203,11 +209,23 @@ nm_tcp_write(NMConn * conn, const void * + if (conn == NULL || buff == NULL) + return -1; + +- if (!conn->use_ssl) +- return (write(conn->fd, buff, len)); +- else if (conn->ssl_conn && conn->ssl_conn->write) +- return (conn->ssl_conn->write(conn->ssl_conn->data, buff, len)); +- else ++ if (!conn->use_ssl) { ++ if (!conn->io || purple_io_get_fd (conn->io) != conn->fd) { ++ if (conn->io) ++ purple_io_destroy (conn->io); ++ conn->io = purple_io_new (conn->fd); ++ } ++ ++ return purple_io_write_bytes (conn->io, buff, len); ++ } else if (conn->ssl_conn && conn->ssl_conn->data && conn->ssl_conn->write) { ++ if (!conn->io || purple_io_get_ssl_connection (conn->io) != conn->ssl_conn->data) { ++ if (conn->io) ++ purple_io_destroy (conn->io); ++ conn->io = purple_io_new_ssl (conn->ssl_conn->data); ++ } ++ ++ return purple_io_write_bytes (conn->io, buff, len); ++ } else + return -1; + } + +diff -uprN gaim-1.5.0-clean/libpurple/protocols/novell/nmconn.h gaim-1.5.0-new-files/libpurple/protocols/novell/nmconn.h +--- gaim-1.5.0-clean/libpurple/protocols/novell/nmconn.h 2004-06-23 13:27:56.000000000 -0400 ++++ gaim-1.5.0-new-files/libpurple/protocols/novell/nmconn.h 2005-10-05 12:53:52.000000000 -0400 +@@ -24,6 +24,7 @@ + typedef struct _NMConn NMConn; + typedef struct _NMSSLConn NMSSLConn; + ++#include "purple-io.h" + #include "nmfield.h" + #include "nmuser.h" + +@@ -42,6 +43,9 @@ struct _NMConn + /* The file descriptor of the socket for the connection. */ + int fd; + ++ /* The buffering I/O wrapper. */ ++ PurpleIO *io; ++ + /* The transaction counter. */ + int trans_id; + +diff -uprN gaim-1.5.0-clean/libpurple/protocols/novell/novell.c gaim-1.5.0-new-files/libpurple/protocols/novell/novell.c +--- gaim-1.5.0-clean/libpurple/protocols/novell/novell.c 2005-07-24 15:27:36.000000000 -0400 ++++ gaim-1.5.0-new-files/libpurple/protocols/novell/novell.c 2005-10-05 14:57:03.000000000 -0400 +@@ -2166,17 +2166,12 @@ static void + novell_close(PurpleConnection * gc) + { + NMUser *user; +- NMConn *conn; + + if (gc == NULL) + return; + + user = gc->proto_data; + if (user) { +- conn = user->conn; +- if (conn && conn->ssl_conn) { +- purple_ssl_close(user->conn->ssl_conn->data); +- } + nm_deinitialize_user(user); + } + gc->proto_data = NULL; diff --git a/pidgin-undefined-operation.patch b/pidgin-undefined-operation.patch new file mode 100644 index 0000000..3609dfb --- /dev/null +++ b/pidgin-undefined-operation.patch @@ -0,0 +1,24 @@ +http://developer.pidgin.im/ticket/889 + +I: Program causes undefined operation + (likely same variable used twiceand post/pre incremented in the same expression). + e.g. x = x++; Split it in two operations. + +gntwm.c: In function 'dump_screen': +gntwm.c:610: warning: operation on 'fgp' may be undefined + +--- finch/libgnt/gntwm.c ++++ finch/libgnt/gntwm.c +@@ -607,7 +607,11 @@ + if (bgp == -1) + bgp = COLOR_WHITE; + if (now & A_REVERSE) +- fgp ^= bgp ^= fgp ^= bgp; /* *wink* */ ++ { ++ short tgp = bgp; ++ bgp = fgp; ++ fgp = tgp; ++ } + ret = color_content(fgp, &r, &g, &b); + fg.r = r; fg.b = b; fg.g = g; + ret = color_content(bgp, &r, &g, &b); diff --git a/pidgin.changes b/pidgin.changes new file mode 100644 index 0000000..459331a --- /dev/null +++ b/pidgin.changes @@ -0,0 +1,22 @@ +------------------------------------------------------------------- +Tue May 15 18:35:19 CEST 2007 - sbrabec@suse.cz + +- Compile with SILC protocol support. +- Integrated patches ported by Martin Szulecki. +- Fixed NSS/NSPR detection. +- Split gaim compatibility binaries. +- Removed obsolete media files. + +------------------------------------------------------------------- +Mon May 14 17:52:45 CEST 2007 - sbrabec@suse.cz + +- Fixed autoreconf. +- Fixed Provides/Obsoletes. +- Require basic SASL plugins required for Jabber. + +------------------------------------------------------------------- +Thu May 10 18:41:44 CEST 2007 - sbrabec@suse.cz + +- New SuSE package, version 2.0.0 (successor of gaim). + Spec file based on work of James Ogley. + diff --git a/pidgin.spec b/pidgin.spec new file mode 100644 index 0000000..4bba28b --- /dev/null +++ b/pidgin.spec @@ -0,0 +1,939 @@ +# +# spec file for package pidgin (Version 2.0.0) +# +# Copyright (c) 2007 SUSE LINUX Products GmbH, Nuernberg, Germany. +# This file and all modifications and additions to the pristine +# package are under the same license as the package itself. +# +# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# + +# norootforbuild + +Name: pidgin +Summary: GTK+-Based Multiprotocol Instant Messaging Client +Version: 2.0.0 +Release: 1 +License: GNU General Public License (GPL) +Group: Productivity/Networking/AOLInstantMessenger +URL: http://www.pidgin.im/ +Source: %{name}-%{version}.tar.bz2 +Source1: pidgin-NLD-smiley-theme.tar.bz2 +Source2: pidgin-Tango-smiley-theme.tar.bz2 +Patch1: pidgin-gnome-keyring.patch +Patch2: pidgin-nonblock-aim.patch +Patch3: pidgin-nonblock-common.patch +Patch4: pidgin-nonblock-gwim.patch +Patch5: pidgin-nonblock-common2.patch +Patch6: pidgin-undefined-operation.patch +Patch7: pidgin-check.patch +# Can use external libzephyr +BuildRequires: cyrus-sasl-devel dbus-1-devel doxygen evolution-data-server-devel gnome-keyring-devel graphviz gtkspell-devel intltool libao-devel libbonobo-devel libgadu-devel libstdc++-devel libxml2-devel meanwhile-devel mono-devel mozilla-nspr-devel mozilla-nss-devel ncurses-devel perl-XML-Parser python sqlite-devel startup-notification-devel tk-devel update-desktop-files +# Product specific lines +%if %suse_version >= 1000 || 0%{?opensuse_bs} +BuildRequires: NetworkManager-devel +%endif +%if %suse_version == 1010 || 0%{?opensuse_bs} +BuildRequires: NetworkManager-gnome +%endif +%if %suse_version >= 1010 || 0%{?opensuse_bs} +BuildRequires: gstreamer010-devel +%else +BuildRequires: gstreamer-devel +%endif +%if %suse_version >= 1011 || 0%{?opensuse_bs} +BuildRequires: dbus-1-glib-devel +%else +BuildRequires: dbus-1-glib +%endif +%if %suse_version >= 1021 || 0%{?opensuse_bs} +BuildRequires: avahi-compat-howl-devel silc-toolkit-devel +%endif +BuildRoot: %{_tmppath}/%{name}-%{version}-build + +%gconf_schemas_prereq + +%description +Pidgin allows you to talk to anyone using a variety of messaging +protocols including AIM, MSN, Yahoo!, Jabber, Bonjour, Gadu-Gadu, ICQ, +IRC, Novell Groupwise, QQ, Lotus Sametime, SILC, Simple and Zephyr. +These protocols are implemented using a modular, easy to use design. +To use a protocol, just add an account using the account editor. + +Pidgin supports many common features of other clients, as well as many +unique features, such as perl scripting, TCL scripting and C plugins. + +Pidgin is not affiliated with or endorsed by America Online, Inc., +Microsoft Corporation, Yahoo! Inc., or ICQ Inc. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + +%package devel +Summary: Development Headers, Documentation, and Libraries for Pidgin +Group: Productivity/Networking/AOLInstantMessenger +Requires: %{name} = %{version} glib2-devel gtk2-devel libpurple-devel = %{version} +%package -n libpurple +Summary: Library for IM Clients Like Pidgin and Finch +Group: Productivity/Networking/AOLInstantMessenger +# Existed before 10.3: +Obsoletes: gaim +# Was never been in SuSE: +Obsoletes: gaim-applet +# Was only in the Build Service after 10.2: +Obsoletes: gaim-unstable +# Not really required, but standard Jabber accounts require it, if compiled with SASL support. +Requires: cyrus-sasl-digestmd5 cyrus-sasl-plain +%package -n libpurple-devel +Summary: Development Headers, Documentation, and Libraries for libpurple +Group: Productivity/Networking/AOLInstantMessenger +Requires: libpurple = %{version} glib2-devel gnome-keyring-devel +Requires: pkg-config +Obsoletes: gaim-devel +Obsoletes: gaim-unstable-devel +%package -n libpurple-meanwhile +Summary: Lotus Sametime Plugin for Pidgin Using the Meanwhile Library +Group: Productivity/Networking/AOLInstantMessenger +Requires: libpurple = %{version} +%package -n libpurple-mono +Summary: Mono .NET Plugin Support for Pidgin +Group: Productivity/Networking/AOLInstantMessenger +Requires: libpurple = %{version} +%package -n finch +Summary: Text-Based User Interface for Pidgin Instant Messaging Client +Group: Productivity/Networking/AOLInstantMessenger +Requires: libpurple = %{version} +Obsoletes: gaim-unstable-text +%package -n finch-devel +Summary: Headers etc. for finch Stuffs +Group: Productivity/Networking/AOLInstantMessenger +Requires: finch = %{version} glib2-devel glibc-devel libpurple-devel = %{version} +Requires: pkg-config +Obsoletes: gaim-unstable-text-devel +%package gaim-compat +Summary: Gaim Compatibility Launchers for Pidgin and Finch +Group: Productivity/Networking/AOLInstantMessenger +Requires: %{name} = %{version} finch = %{version} +Conflicts: gaim < 2.0.0 +Conflicts: gaim-unstable < 2.0.0 + +%description devel +The pidgin-devel package contains the header files, developer +documentation, and libraries required for development of Pidgin scripts +and plugins. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + + +%description -n libpurple +libpurple contains the core IM support for IM clients such as Pidgin +and Finch. + +libpurple supports a variety of messaging protocols including AIM, MSN, +Yahoo!, Jabber, Bonjour, Gadu-Gadu, ICQ, IRC, Novell Groupwise, QQ, +Lotus Sametime, SILC, Simple and Zephyr. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + + +%description -n libpurple-devel +The libpurple-devel package contains the header files, developer +documentation, and libraries required for development of libpurple +based instant messaging clients or plugins for any libpurple based +client. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + + +%description -n libpurple-meanwhile +Lotus Sametime plugin for Pidgin using the Meanwhile library. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + + +%description -n libpurple-mono +Mono plugin loader for Pidgin. This package will allow you to write or +use Pidgin plugins written in the .NET programming language. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + + +%description -n finch +A text-based user interface for using libpurple. This can be run from +a standard text console or from a terminal within X Windows. It uses +ncurses and our homegrown gnt library for drawing windows and text. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + + +%description -n finch-devel +The finch-devel package contains the header files, developer +documentation, and libraries required for development of Finch scripts +and plugins. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + + +%description gaim-compat +This package provides compatibility binaries for gaim and gaim-text to +notify users, that they should update their configuration to use new +name. + + + +Authors: +-------- + Sean Egan + Daniel 'datallah' Atallah + Ethan 'Paco-Paco' Blanton + Thomas Butter + Sadrul Habib Chowdhury + Mark 'KingAnt' Doliner + Christian 'ChipX86' Hammond & Webmaster + Gary 'grim' Kramlich + Richard 'rlaager' Laager + Richard 'wabz' Nelson + Christopher 'siege' O'Brien + Bartosz Oler + Etan 'deryni' Reisner + Tim 'marv' Ringenbach + Luke 'LSchiere' Schierer + Megan 'Cae' Schneider + Evan Schoenberg + Stu 'nosnilmot' Tomlinson + Nathan 'faceprint' Walp + John 'rekkanoryo' Bailey + Ka-Hing 'javabsp' Cheung + Felipe 'shx' Contreras + Decklin Foster + Casey Harkins + Peter 'Bleeter' Lawler + Robert 'Robot101' McQueen + Benjamin Miller + Kevin 'SimGuy' Stange + Herman Bloggs + Jim Duchek + Rob Flynn + Adam Fritzler + Syd Logan + Jim Seymour + Mark Spencer + Eric Warmenhoven + Hylke Bons + Naru Sundar + Peter Teichiman + Larry Ewing + Jeramey A. Crawford + Nathan Walp + Neil Sanchala + Arkadiusz Miskiewicz + David Prater + Sébastien Carp + Ari Pollak + Decklin Foster + David + S D Erle + BMiller + Lance Rocker + ergofobe + Justin M. Ward + G. Sumner Hayes + Brian Ryner + Ryan C. Gordon + Elliot Tobin + Jeroen van der Vegt + The OpenQ Team + +%prep +%setup -q -a1 -a2 +%patch1 -p1 +# FIXME: Port this patch: +#%patch2 -p1 +%patch3 -p1 +%patch4 -p1 +%patch5 -p1 +%patch6 +%patch7 +# Change Myanmar/Myanmar to Myanmar: +rename my_MM my po/my_MM.* +sed -i "/^ALL_LINGUAS/s/ my_MM / my /" configure.ac + +%build +# -fno-strict-aliasing needed for 2.0.0 +%if %suse_version > 1000 +export CFLAGS="$RPM_OPT_FLAGS -fstack-protector -fPIC -fno-strict-aliasing" +export LDFLAGS="-pie" +%else +export CFLAGS="$RPM_OPT_FLAGS -fPIC -fno-strict-aliasing" +%endif +ACLOCAL="aclocal -I m4macros" autoreconf -f -i +%configure\ + --disable-static\ + --enable-plugins\ + --enable-cyrus-sasl\ + --enable-dbus=yes\ + --enable-mono=yes\ + --enable-gstreamer=yes\ + --enable-gnome-keyring=yes\ + --enable-nm=yes\ + --enable-dbus=yes\ + --with-perl-lib=/usr\ + --with-nspr-includes=/usr/include/nspr4\ + --with-nss-includes=/usr/include/nss3\ + --with-tclconfig=/usr/%_lib\ + --with-tkconfig=/usr/%_lib +make +# Mono bindings 2.0.0 are not parallel build ready: +#make %{?jobs:-j%jobs} + +%install +%makeinstall +%perl_process_packlist +%suse_update_desktop_file -N Pidgin -G "Instant Messenger" %{name} InstantMessaging +cp -a NLD $RPM_BUILD_ROOT%{_prefix}/share/pixmaps/pidgin/emotes +cp -a Tango $RPM_BUILD_ROOT%{_prefix}/share/pixmaps/pidgin/emotes +rm $RPM_BUILD_ROOT%{_prefix}/%_lib/pidgin/*.*a +# FIXME: Should be nonversioned name: +test -L $RPM_BUILD_ROOT%{_libdir}/purple-2/liboscar.so && rm $RPM_BUILD_ROOT%{_libdir}/purple-2/liboscar.so +test -L $RPM_BUILD_ROOT%{_libdir}/purple-2/libjabber.so && rm $RPM_BUILD_ROOT%{_libdir}/purple-2/libjabber.so +#find $RPM_BUILD_ROOT -type f -name .packlist -exec rm {} ';' +#find $RPM_BUILD_ROOT -type f -name '*.bs' -empty -exec rm {} ';' +# binaries for gaim rename notification: +cat >$RPM_BUILD_ROOT%{_bindir}/gaim <&2 "WARNING: gaim was replaced by pidgin. Please call it as \"pidgin\"." +( +exec 2>/dev/null +zenity --window-icon /usr/share/icons/hicolor/24x24/apps/pidgin.png --warning --text "WARNING: gaim was replaced by pidgin. Please call it as \"pidgin\"." & +KPID=\$! +( sleep 7 ; kill \$KPID ) & +wait \$KPID +) +exec %{_bindir}/pidgin "\$@" +EOF +chmod +x $RPM_BUILD_ROOT%{_bindir}/gaim +cat >$RPM_BUILD_ROOT%{_bindir}/gaim-text <&2 "WARNING: gaim-text was replaced by finch. Please call it as \"finch\"." +exec %{_bindir}/finch "\$@" +EOF +chmod +x $RPM_BUILD_ROOT%{_bindir}/gaim-text +%find_lang %{name} +rm $RPM_BUILD_ROOT%{_libdir}/*/*.la +# NOTE: Original has also "grep -v /libbonjour.so | \" +find $RPM_BUILD_ROOT%{_libdir}/purple-2 -xtype f -print | \ + sed "s@^$RPM_BUILD_ROOT@@g" | \ + grep -v /libsametime.so | \ + grep -v /mono.so | \ + grep -v ".dll$" > %{name}-%{version}-purpleplugins +find $RPM_BUILD_ROOT%{_libdir}/pidgin -xtype f -print | \ + sed "s@^$RPM_BUILD_ROOT@@g" > %{name}-%{version}-pidginplugins +find $RPM_BUILD_ROOT%{_libdir}/finch -xtype f -print | \ + sed "s@^$RPM_BUILD_ROOT@@g" > %{name}-%{version}-finchplugins +%find_gconf_schemas +cat %{name}.schemas_list %{name}-%{version}-pidginplugins >%{name}.lst +cat %{name}.lang %{name}-%{version}-purpleplugins >libpurple.lst + +%clean +rm -rf $RPM_BUILD_ROOT + +%pre -f %{name}.schemas_pre + +%posttrans -f %{name}.schemas_posttrans + +%preun -f %{name}.schemas_preun + +%files -f %{name}.lst +%defattr(-,root,root) +%doc AUTHORS COPYING COPYRIGHT ChangeLog NEWS README README.MTN doc/the_penguin.txt +%dir %{_libdir}/pidgin +%{perl_vendorarch}/Pidgin.pm +%{perl_vendorarch}/auto/Pidgin +%{_bindir}/pidgin +%{_datadir}/pixmaps/pidgin +%{_datadir}/icons/hicolor/*/apps/pidgin.* +%dir %{_datadir}/sounds/pidgin +%{_datadir}/sounds/pidgin/* +%{_datadir}/applications/*.desktop +%doc %{_mandir}/man1/pidgin.* +%doc %{_mandir}/man3/Pidgin.* +/var/adm/perl-modules/pidgin + +%files devel +%defattr(-,root,root) +%{_includedir}/pidgin +%{_libdir}/pkgconfig/pidgin.pc + +%files -f libpurple.lst -n libpurple +%defattr(-, root, root) +%doc libpurple/purple-notifications-example +%{_bindir}/purple-client-example +%{_bindir}/purple-remote +%{_bindir}/purple-send +%{_bindir}/purple-send-async +%{_bindir}/purple-url-handler +%{_datadir}/pixmaps/purple +%{_libdir}/libpurple.so.* +%{_libdir}/libpurple-client.so.* +%dir %{_libdir}/purple-2 +%{perl_vendorarch}/Purple.pm +%{perl_vendorarch}/auto/Purple + +%files -n libpurple-meanwhile +%defattr(-, root, root) +%{_libdir}/purple-2/libsametime.* + +%files -n libpurple-mono +%defattr(-, root, root) +%{_libdir}/purple-2/mono.so +%{_libdir}/purple-2/*.dll + +%files -n libpurple-devel +%defattr(-, root, root) +%doc ChangeLog.API HACKING PLUGIN_HOWTO +%{_includedir}/libpurple +%{_datadir}/aclocal/purple.m4 +%{_libdir}/libpurple.so +%{_libdir}/libpurple.*a +%{_libdir}/libpurple-client.so +%{_libdir}/libpurple-client.*a +%{_libdir}/pkgconfig/purple.pc +%doc %{_mandir}/man3/Purple.* + +%files -f %{name}-%{version}-finchplugins -n finch +%defattr(-, root, root) +%{_bindir}/finch +%{_libdir}/libgnt.so.* +%dir %{_libdir}/finch +%doc %{_mandir}/man1/finch.* + +%files -n finch-devel +%defattr(-, root, root) +%{_includedir}/finch +%{_includedir}/gnt +%{_libdir}/libgnt.so +%{_libdir}/libgnt.*a +%{_libdir}/pkgconfig/gnt.pc + +%files gaim-compat +%defattr(-, root, root) +%{_bindir}/gaim +%{_bindir}/gaim-text + +%changelog +* Tue May 15 2007 - sbrabec@suse.cz +- Compile with SILC protocol support. +- Integrated patches ported by Martin Szulecki. +- Fixed NSS/NSPR detection. +- Split gaim compatibility binaries. +- Removed obsolete media files. +* Mon May 14 2007 - sbrabec@suse.cz +- Fixed autoreconf. +- Fixed Provides/Obsoletes. +- Require basic SASL plugins required for Jabber. +* Thu May 10 2007 - sbrabec@suse.cz +- New SuSE package, version 2.0.0 (successor of gaim). + Spec file based on work of James Ogley. diff --git a/ready b/ready new file mode 100644 index 0000000..473a0f4