xmlnode * _h_elim_image ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
xmlnode *rval = xnode_new( "alist" );
int image_id = (int)ALIST_VAL_INT( args, "image-id" );
if( image_id <= 0 )
{
sexp_val_free( args );
return response_error( EINVAL, id, name, "bad image ID" );
}
fprintf( stderr, "searching for image id %d\n", image_id );
PurpleStoredImage *image = purple_imgstore_find_by_id( image_id );
if( !image )
{
sexp_val_free( args );
return response_error( ENOENT, id, name, "image ID not found" );
}
size_t size = IGET( image , size );
AL_INT ( rval, "image-id" , image_id );
AL_INT ( rval, "image-size", size );
AL_STR ( rval, "image-file", IGET( image, filename ) );
AL_STR ( rval, "image-type", IGET( image, extension ) );
AL_DATA( rval, "image-data", IGET( image, data ) , size );
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
xmlnode * _h_elim_send_file ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
elim_ping();
const char *aname = ALIST_VAL_STR( args, "account-name" );
const char *proto = ALIST_VAL_STR( args, "im-protocol" );
gpointer auid = ALIST_VAL_PTR( args, "account-uid" );
PurpleAccount *acct =
auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto );
if( !acct )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "unknown account" );
}
PurpleConnection *conn = purple_account_get_connection( acct );
if( !conn )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "account not online" );
}
// file can be NULL, but that's Ok, it just triggers a req to the user:
const char *b_arg = ALIST_VAL_STRING( args, "recipient" );
const char *file = ALIST_VAL_STRING( args, "filename" );
serv_send_file( conn, b_arg, file );
// bname is a static buf allocated in purple_normalize: don't free it!
// also, this means that bname is volatile, so use it immediately after
// acquiring it, if you make any calls into libpurple they might invalidate
// its state:
const char *bname = purple_normalize( acct, b_arg );
xmlnode *rval = xnode_new( "alist" );
AL_PTR( rval, "account-uid" , acct );
AL_STR( rval, "recipient" , bname );
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
xmlnode * _h_elim_init ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
char *dir = ALIST_VAL_STRING( args, "dot-dir" );
char *ui = ALIST_VAL_STRING( args, "ui-id" );
gboolean dbg = ALIST_VAL_BOOL ( args, "debug" );
if( !ui ) { ui = "elim"; }
// libpurple initialisation:
purple_util_set_user_dir ( dir );
purple_util_init ();
purple_core_set_ui_ops ( &elim_core_ui_ops );
purple_eventloop_set_ui_ops ( &elim_eventloop_ui_ops );
purple_blist_set_ui_ops ( &elim_blist_ui_ops );
purple_accounts_set_ui_ops ( &elim_account_ui_ops );
purple_request_set_ui_ops ( &elim_request_ui_ops );
purple_idle_set_ui_ops ( &elim_idle_ui_ops );
purple_connections_set_ui_ops ( &elim_connections_ui_ops );
purple_conversations_set_ui_ops( &elim_conversation_ui_ops );
purple_notify_set_ui_ops ( &elim_notify_ui_ops );
// load any data for init:
if( purple_get_core() == NULL )
{
// purple debug goes to stdout if we don't divert it here:
g_set_print_handler( (GPrintFunc)_h_elim_warning );
// look for plugins in user specified directory tree:
char *ppath = g_build_filename( purple_user_dir(), "plugins", NULL );
purple_plugins_add_search_path ( ppath );
purple_debug_set_enabled( dbg );
purple_core_init ( ui );
purple_set_blist ( purple_blist_new() );
purple_prefs_load();
purple_blist_load();
// glib signal initialisation:
elim_ft_signals_init();
// tidy up:
g_free( ppath );
}
else
{
const char *cur_ui = purple_core_get_ui();
if( strcmp( cur_ui, name ) )
{
sexp_val_free( args );
return response_error( EINVAL, id, name,
"purple has already been initialised" );
}
}
sexp_val_free( args );
xmlnode *rval = xnode_new( "alist" );
AL_STR( rval, "ui-id", purple_core_get_ui() );
return response_value( 0, id, name, rval );
}
xmlnode * _h_elim_status ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
fprintf(stderr, "(elim-debug entered _h_elim_status)");
ASSERT_ALISTP( args, id, name );
elim_ping();
const char *sid = ALIST_VAL_STR( args, "status-id" );
const char *mesg = ALIST_VAL_STR( args, "status-message" );
signed int _stype = ALIST_VAL_INT( args, "status-type" );
PurpleSavedStatus *status = purple_savedstatus_find( sid );
PurpleStatusPrimitive stype = PURPLE_STATUS_UNSET;
// create a new status:
if( !status )
{
CHECK_STATUS ( args, id, name, stype, _stype );
status = purple_savedstatus_new( sid, stype );
if( status )
{
if ( mesg ) purple_savedstatus_set_message( status, mesg );
else if( sid ) purple_savedstatus_set_message( status, sid );
}
}
else
{
if( mesg ) purple_savedstatus_set_message( status, mesg );
}
if( !status )
{
sexp_val_free( args );
return response_error( EINVAL, id, name, "Could not create status" );
}
purple_savedstatus_activate( status );
xmlnode *rval = xnode_new( "alist" );
AL_STR ( rval, "status-id" , purple_savedstatus_get_title (status) );
AL_STR ( rval, "status-message", purple_savedstatus_get_message(status) );
AL_ENUM( rval, "status-type" , purple_savedstatus_get_type (status) ,
":status-primitive" );
sexp_val_free( args );
fprintf(stderr, "(elim-debug leaving _h_elim_status)");
return response_value( 0, id, name, rval );
}
xmlnode * _h_elim_set_icon ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
elim_ping();
const char *aname = ALIST_VAL_STR ( args, "account-name" );
const char *proto = ALIST_VAL_STR ( args, "im-protocol" );
gpointer auid = ALIST_VAL_PTR ( args, "account-uid" );
const char *file = ALIST_VAL_STR ( args, "icon-file" );
GString *img = ALIST_VAL_DATA( args, "icon-data" );
gchar *bytes = NULL;
gsize len = 0;
gpointer set = NULL;
PurpleAccount *acct =
auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto );
if( !acct )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "unknown account" );
}
if( !img && file && *file )
{
g_file_get_contents( file, &bytes, &len, NULL );
}
else if( img )
{
bytes = g_memdup( img->str, img->len );
len = img->len;
}
// the imgstore owns `bytes' after this, don't free it:
set = purple_buddy_icons_set_account_icon( acct, (guchar *)bytes, len );
xmlnode *rval = xnode_new( "alist" );
AL_PTR ( rval, "account-uid" , acct );
AL_STR ( rval, "account-name", purple_account_get_username ( acct ) );
AL_STR ( rval, "im-protocol" , purple_account_get_protocol_id( acct ) );
AL_BOOL( rval, "has-icon" , set ? TRUE : FALSE );
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
static void
on_write(uv_write_t* req, int status) {
http_response* response = (http_response*) req->data;
if (status != 0) {
fprintf(stderr, "Write error: %s: %s\n", uv_err_name(status), uv_strerror(status));
destroy_response(response, 1);
return;
}
if (response->response_offset >= response->response_size) {
destroy_response(response, !response->request->keep_alive);
return;
}
int r = uv_fs_read(loop, &response->read_req, response->fd, &response->buf, 1, response->response_offset, on_fs_read);
if (r) {
fprintf(stderr, "File read error: %s: %s\n", uv_err_name(r), uv_strerror(r));
response_error(response->handle, 500, "Internal Server Error", NULL);
destroy_request(response->request, 1);
}
}
static void
on_fs_read(uv_fs_t *req) {
http_response* response = (http_response*) req->data;
int result = req->result;
uv_fs_req_cleanup(req);
if (result < 0) {
fprintf(stderr, "File read error: %s: %s\n", uv_err_name(result), uv_strerror(result));
response_error(response->handle, 500, "Internal Server Error", NULL);
destroy_response(response, 1);
return;
} else if (result == 0) {
destroy_response(response, 1);
return;
}
uv_buf_t buf = uv_buf_init(response->pbuf, result);
int r = uv_write(&response->write_req, (uv_stream_t*) response->handle, &buf, 1, on_write);
if (r) {
destroy_response(response, 1);
return;
}
response->response_offset += result;
}
static void
request_complete(http_request* request) {
memcpy(request->file_path, static_dir, static_dir_len);
memcpy(request->file_path + static_dir_len, request->path, request->path_len);
if (*(request->path + request->path_len - 1) == '/') {
memcpy(request->file_path + static_dir_len + 1, "index.html", 11);
} else
request->file_path[static_dir_len + request->path_len] = 0;
request->keep_alive = find_header_value(request, "Connection", "keep-alive");
uv_fs_t* open_req = malloc(sizeof(uv_fs_t));
if (open_req == NULL) {
fprintf(stderr, "Allocate error: %s\n", strerror(errno));
return;
}
open_req->data = request;
int r = uv_fs_open(loop, open_req, request->file_path, O_RDONLY, S_IREAD, on_fs_open);
if (r) {
fprintf(stderr, "Open error: %s: %s\n", uv_err_name(r), uv_strerror(r));
response_error(request->handle, 404, "Not Found\n", NULL);
destroy_request(request, 1);
free(open_req);
}
}
static void
on_fs_open(uv_fs_t* req) {
http_request* request = (http_request*) req->data;
int result = req->result;
uv_fs_req_cleanup(req);
free(req);
if (result < 0) {
fprintf(stderr, "Open error: %s: %s\n", uv_err_name(result), uv_strerror(result));
response_error(request->handle, 404, "Not Found\n", NULL);
destroy_request(request, 1);
return;
}
uv_fs_t stat_req;
int r = uv_fs_fstat(loop, &stat_req, result, NULL);
if (r) {
fprintf(stderr, "Stat error: %s: %s\n", uv_err_name(r), uv_strerror(r));
response_error(request->handle, 404, "Not Found\n", NULL);
destroy_request(request, 1);
return;
}
uint64_t response_size = stat_req.statbuf.st_size;
uv_fs_req_cleanup(&stat_req);
const static char* ctype = "application/octet-stream";
const char* dot = request->file_path;
const char* ptr = dot;
while (dot) {
ptr = dot;
dot = strchr(dot + 1, '.');
}
khint_t k = kh_get(mime_type, mime_type, ptr);
if (k != kh_end(mime_type)) {
ctype = kh_value(mime_type, k);
}
http_response* response = calloc(1, sizeof(http_response));
if (response == NULL) {
fprintf(stderr, "Allocate error: %s\n", strerror(r));
response_error(request->handle, 404, "Not Found\n", NULL);
destroy_request(request, 1);
return;
}
response->response_size = response_size;
response->fd = result;
response->request = request;
response->handle = request->handle;
response->pbuf = malloc(WRITE_BUF_SIZE);
if (response->pbuf == NULL) {
fprintf(stderr, "Allocate error: %s\n", strerror(r));
response_error(request->handle, 404, "Not Found\n", NULL);
destroy_response(response, 1);
return;
}
response->buf = uv_buf_init(response->pbuf, WRITE_BUF_SIZE);
response->read_req.data = response;
response->write_req.data = response;
char bufline[1024];
int nbuf = snprintf(bufline,
sizeof(bufline),
"HTTP/1.1 200 OK\r\n"
"Content-Length: %" PRId64 "\r\n"
"Content-Type: %s\r\n"
"Connection: %s\r\n"
"\r\n",
response_size,
ctype,
(request->keep_alive ? "keep-alive" : "close"));
uv_buf_t buf = uv_buf_init(bufline, nbuf);
#ifndef _WIN32
r = uv_try_write((uv_stream_t*) request->handle, &buf, 1);
if (r == 0) {
fprintf(stderr, "Write error\n");
destroy_response(response, 1);
return;
}
#else
r = uv_write(&response->write_req, (uv_stream_t*) request->handle, &buf, 1, NULL);
if (r) {
fprintf(stderr, "Write error: %s: %s\n", uv_err_name(r), uv_strerror(r));
destroy_response(response, 1);
return;
}
#endif
r = uv_fs_read(loop, &response->read_req, result, &response->buf, 1, -1, on_fs_read);
if (r) {
response_error(request->handle, 500, "Internal Server Error\n", NULL);
destroy_response(response, 1);
}
}
xmlnode * _h_elim_add_buddy ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
elim_ping();
int loopc = 0;
const char *aname = ALIST_VAL_STR( args, "account-name" );
const char *proto = ALIST_VAL_STR( args, "im-protocol" );
gpointer auid = ALIST_VAL_PTR( args, "account-uid" );
PurpleAccount *acct =
auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto );
if( !acct )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "unknown account" );
}
const char *b_arg = ALIST_VAL_STRING( args, "bnode-name" );
const char *bname = purple_normalize( acct, b_arg );
const char *gname = ALIST_VAL_STRING( args, "group" );
if( !gname || !*gname ) gname = "Buddies";
PurpleGroup *group = purple_group_new( gname );
PurpleBuddy *buddy = purple_buddy_new( acct, bname, b_arg );
PurpleBuddy *clone = NULL;
//fprintf( stderr, "add-buddy( b: %p, g: %p )\n", buddy, group );
// remove other references to this buddy
purple_blist_add_buddy ( buddy, NULL, group, NULL );
purple_account_add_buddy( acct , buddy );
while( ( clone = (PurpleBuddy*)find_blist_node_clone( buddy ) ) )
{
if( loopc++ > 99 )
{
fprintf( stderr, "ARGH! clone reaping looped: %d\n", loopc );
break;
}
if( clone == buddy )
{
fprintf( stderr, "ARGH! %p not a clone of %p\n", buddy, clone );
break;
}
fprintf( stderr, "(removing clone %p %ld (of buddy: %p)\n",
clone, (long)clone, buddy );
fprintf( stderr, " name : %s\n", purple_buddy_get_name(clone) );
fprintf( stderr, " group: %s)\n",
purple_group_get_name( purple_buddy_get_group(clone) ) );
purple_blist_remove_buddy( clone );
}
xmlnode *rval = xnode_new( "alist" );
AL_PTR( rval, "account-uid" , acct );
AL_PTR( rval, "bnode-uid" , buddy );
AL_PTR( rval, "group-uid" , group );
AL_STR( rval, "bnode-name" , purple_buddy_get_name ( buddy ) );
AL_STR( rval, "bnode-alias" , purple_buddy_get_alias ( buddy ) );
AL_STR( rval, "account-name", purple_account_get_username ( acct ) );
AL_STR( rval, "im-protocol" , purple_account_get_protocol_id( acct ) );
AL_STR( rval, "group-name" , purple_group_get_name ( group ) );
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
xmlnode * _h_elim_message ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
fprintf(stderr, "(elim-debug entered _h_elim_message)");
ASSERT_ALISTP( args, id, name );
elim_ping();
const char *aname = ALIST_VAL_STR( args, "account-name" );
const char *proto = ALIST_VAL_STR( args, "im-protocol" );
gpointer auid = ALIST_VAL_PTR( args, "account-uid" );
PurpleAccount *acct =
auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto );
if( !acct )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "unknown account" );
}
PurpleConversationType pt = PURPLE_CONV_TYPE_UNKNOWN;
gpointer cuid = ALIST_VAL_PTR( args, "conv-uid" );
const char *cname = ALIST_VAL_STR( args, "conv-name" );
PurpleConversation *pc = find_conv_by_acct_uid( acct, cuid );
if ( pc ) pt = purple_conversation_get_type( pc );
else
{
pt = PURPLE_CONV_TYPE_ANY;
pc = purple_find_conversation_with_account( pt, cname, acct );
if( !pc )
{
pt = PURPLE_CONV_TYPE_IM;
pc = purple_conversation_new( pt, acct, cname );
}
else { pt = purple_conversation_get_type( pc ); }
}
if( !pc )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "new conversation failed" );
}
PurpleConvIm *pci = NULL;
PurpleConvChat *pcc = NULL;
const char *msg = ALIST_VAL_STRING( args, "text" );
char *esc = g_markup_escape_text( msg, -1 );
int len = strlen( esc );
switch( pt )
{
case PURPLE_CONV_TYPE_IM:
pci = purple_conversation_get_im_data( pc );
purple_conv_im_send( pci, esc );
break;
case PURPLE_CONV_TYPE_CHAT:
pcc = purple_conversation_get_chat_data( pc );
purple_conv_chat_send( pcc, esc );
break;
default:
g_free ( esc );
sexp_val_free( args );
return response_error( EINVAL, id, name, "unknown conversation type" );
}
xmlnode *rval = xnode_new( "alist" );
AL_INT( rval, "bytes" , len );
AL_PTR( rval, "conv-uid" , pc );
AL_STR( rval, "conv-name", purple_conversation_get_name(pc) );
g_free ( esc );
sexp_val_free( args );
fprintf(stderr, "(elim-debug leaving _h_elim_message)");
return response_value( 0, id, name, rval );
}
void HttpProxy::handle_async(
boost::system::error_code const & ec,
Size const & bytes_transferred)
{
LOG_SECTION();
LOG_DEBUG("[handle_async] (id = %u, status = %s, ec = %s, bytes_transferred = %s)"
%id_ % state_str[state_] % ec.message() % bytes_transferred.to_string());
if (watch_state_ == broken) {
on_finish();
delete this;
return;
}
if (ec) {
if (state_ == receiving_request_head) {
error_code ec1;
response_.clear_data();
bool block = !get_non_block(ec1);
if (block)
set_non_block(true, ec1);
boost::asio::read(*this, response_.data(), boost::asio::transfer_at_least(4096), ec1);
if (block)
set_non_block(false, ec1);
LOG_DATA(framework::logger::Debug, ("receiving_request_head", response_.data().data()));
}
on_error(ec);
switch (state_) {
case receiving_request_head:
case transferring_request_data:
case sending_response_head:
case transferring_response_data:
on_finish();
state_ = exiting;
if (watch_state_ == watching) {
error_code ec1;
HttpSocket::cancel(ec1);
} else {
delete this;
}
break;
case local_processing:
if (is_local() && !response_.head().content_length.is_initialized() && bytes_transferred.is_size_t()) {
response_.head().content_length.reset(bytes_transferred.get_size_t());
}
case preparing:
case connectting:
case sending_request_head:
case receiving_response_head:
state_ = sending_response_head;
response_error(ec, boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
default:
assert(0);
break;
}
return;
}
switch (state_) {
case stopped:
state_ = receiving_request_head;
response_.head() = HttpResponseHead();
async_read(request_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case receiving_request_head:
state_ = preparing;
if (watch_state_ == watch_stopped
&& request_.head().content_length.get_value_or(0) == 0) {
watch_state_ = watching;
async_read_some(boost::asio::null_buffers(),
boost::bind(&HttpProxy::handle_watch, this, _1));
}
on_receive_request_head(
request_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case preparing:
if (bytes_transferred.get_bool()) {
if (!http_to_server_)
http_to_server_ = new HttpSocket(get_io_service());
state_ = connectting;
http_to_server_->async_connect(request_.head().host.get(),
boost::bind(&HttpProxy::handle_async, this, _1, Size()));
} else {
state_ = transferring_request_data;
transfer_request_data(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
}
break;
case connectting:
state_ = sending_request_head;
http_to_server_->async_write(request_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case sending_request_head:
state_ = transferring_request_data;
transfer_request_data(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case transferring_request_data:
if (is_local()) {
on_receive_request_data(transfer_buf_);
transfer_buf_.consume(transfer_buf_.size());
}
state_ = local_processing;
if (watch_state_ == watch_stopped) {
watch_state_ = watching;
async_read_some(boost::asio::null_buffers(),
boost::bind(&HttpProxy::handle_watch, this, _1));
}
response_.head().connection = request_.head().connection;
local_process(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case local_processing:
if (is_local()) {
state_ = receiving_response_head;
on_receive_response_head(response_.head());
if (!response_.head().content_length.is_initialized()) {
if (bytes_transferred.is_size_t())
response_.head().content_length.reset(bytes_transferred.get_size_t());
else
response_.head().connection.reset(http_field::Connection());
}
if (!response_.head().connection.is_initialized()) {
response_.head().connection.reset(http_field::Connection());
}
handle_async(ec, Size());
} else {
state_ = receiving_response_head;
http_to_server_->async_read(response_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
}
break;
case receiving_response_head:
if (!is_local()) {
on_receive_response_head(response_.head());
if (!response_.head().connection.is_initialized()) {
response_.head().connection.reset(http_field::Connection());
}
if (response_.head().err_msg.empty())
response_.head().err_msg = "OK";
}
state_ = sending_response_head;
async_write(response_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case sending_response_head:
state_ = transferring_response_data;
transfer_response_data(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case transferring_response_data:
on_finish();
if (!response_.head().connection
|| response_.head().connection.get() == http_field::Connection::close) {
state_ = exiting;
if (watch_state_ != watching) {
delete this;
} else {
error_code ec;
shutdown(boost::asio::socket_base::shutdown_send, ec);
boost::asio::ip::tcp::socket::cancel(ec);
}
} else {
state_ = stopped;
if (watch_state_ != watching) {
// restart
watch_state_ = watch_stopped;
handle_async(ec, Size());
} else {
error_code ec;
boost::asio::ip::tcp::socket::cancel(ec);
}
}
break;
default:
assert(0);
break;
}
}
xmlnode * _h_elim_remove_buddy ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
fprintf( stderr, "(elim-remove-buddy)\n" );
elim_ping();
const char *aname = ALIST_VAL_STR( args, "account-name" );
const char *proto = ALIST_VAL_STR( args, "im-protocol" );
gpointer auid = ALIST_VAL_PTR( args, "account-uid" );
PurpleAccount *acct = NULL;
gpointer b_uid = ALIST_VAL_PTR( args, "bnode-uid" );
const char *b_arg = NULL;
const char *bname = NULL;
const char *gname = NULL;
PurpleGroup *group = NULL;
PurpleBuddy *buddy = NULL;
gboolean gone = FALSE;
if( b_uid )
{
PurpleBlistNodeType type = PURPLE_BLIST_OTHER_NODE;
PurpleBlistNode *node = find_blist_node_by_uid( b_uid , TRUE );
if( !node )
{
sexp_val_free( args );
return response_error( EINVAL, id, name, "rogue buddy pointer" );
}
type = purple_blist_node_get_type( node );
// ===========================================================
// groups, contacts and chats can safely be removed here:
// buddies should instead be noted for removal in the next
// block of code as they require client<->server interaction:
switch( type )
{
case PURPLE_BLIST_GROUP_NODE :
purple_blist_remove_group ( (PurpleGroup *)node );
gone = TRUE;
break;
case PURPLE_BLIST_CONTACT_NODE:
purple_blist_remove_contact( (PurpleContact *)node );
gone = TRUE;
break;
case PURPLE_BLIST_CHAT_NODE :
FIND_ACCOUNT( args, id, name, acct, auid, aname, proto );
BNODE_ACCOUNT_CHECK(chat,(PurpleChat *)node, acct, args, id, name);
purple_blist_remove_chat ( (PurpleChat *)node );
gone = TRUE;
break;
case PURPLE_BLIST_BUDDY_NODE :
buddy = (PurpleBuddy *)node;
FIND_ACCOUNT( args, id, name, acct, auid, aname, proto );
BNODE_ACCOUNT_CHECK( buddy, buddy, acct, args, id, name );
b_arg = purple_buddy_get_name( buddy );
bname = purple_normalize( acct, b_arg );
break;
default:
sexp_val_free( args );
return response_error( EINVAL, id, name,
"Unknown buddy list node type" );
}
if( gone )
{
xmlnode *rval = xnode_new( "alist" );
if( acct )
{
AL_STR( rval, "account-name", aname );
AL_STR( rval, "im-protocol" , proto );
AL_PTR( rval, "account-uid" , acct );
}
AL_PTR ( rval, "bnode-uid" , buddy );
AL_ENUM( rval, "bnode-type", type , ":blist-node-type" );
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
}
else
{
b_arg = ALIST_VAL_STRING( args, "bnode-name" );
FIND_ACCOUNT( args, id, name, acct, auid, aname, proto );
if( b_arg )
{
bname = purple_normalize( acct, b_arg );
gname = ALIST_VAL_STRING( args, "group" );
group = ( gname && *gname ) ? purple_find_group( gname ) : NULL;
buddy = ( group ?
purple_find_buddy_in_group( acct, bname, group ) :
purple_find_buddy ( acct, bname ) );
}
}
if( !b_arg || !*b_arg )
{
sexp_val_free( args );
return response_error( EINVAL, id, name, "buddy not specified" );
}
// buddy must be in our local list or libpurple won't remove it from the
// server list ( determined empirically, confirmed by inspecting code ):
if( !buddy )
{
buddy = purple_buddy_new( acct, bname, bname );
purple_blist_add_buddy ( buddy, NULL, NULL, NULL );
}
if( buddy )
{
// the order of the remove operations is important: it has to be
// this way round, as noted above: account buddy removal won't
// happen if the buddy is not in the blist when we try:
if( !group ) group = purple_buddy_get_group( buddy );
// is this correct? what if we have more than one copy of said buddy?
// potentially confusing. dunno what the right thing to do is here.
purple_account_remove_buddy( acct, buddy, group );
purple_blist_remove_buddy( buddy );
}
else
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "no such buddy" );
}
xmlnode *rval = xnode_new( "alist" );
AL_STR ( rval, "account-name", purple_account_get_username ( acct ) );
AL_STR ( rval, "im-protocol" , purple_account_get_protocol_id( acct ) );
AL_PTR ( rval, "account-uid" , acct );
AL_PTR ( rval, "bnode-uid" , buddy );
AL_ENUM( rval, "bnode-type", PURPLE_BLIST_BUDDY_NODE, ":blist-node-type" );
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
xmlnode * _h_elim_command ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
fprintf(stderr, "(elim-debug entered _h_elim_command)");
ASSERT_ALISTP( args, id, name );
elim_ping();
const char *aname = ALIST_VAL_STR( args, "account-name" );
const char *proto = ALIST_VAL_STR( args, "im-protocol" );
gpointer auid = ALIST_VAL_PTR( args, "account-uid" );
PurpleAccount *acct =
auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto );
if( !acct )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "unknown account" );
}
PurpleConversationType pt = PURPLE_CONV_TYPE_UNKNOWN;
gpointer cuid = ALIST_VAL_PTR( args, "conv-uid" );
const char *cname = ALIST_VAL_STR( args, "conv-name" );
PurpleConversation *pc = find_conv_by_acct_uid( acct, cuid );
if ( pc ) pt = purple_conversation_get_type( pc );
else
{
pt = PURPLE_CONV_TYPE_ANY;
pc = purple_find_conversation_with_account( pt, cname, acct );
if( !pc )
{
sexp_val_free( args );
return response_error( ENOENT, id, name, "conversation not found" );
}
else { pt = purple_conversation_get_type( pc ); }
}
PurpleCmdStatus c_s = PURPLE_CMD_STATUS_FAILED;
const char *cmd = ALIST_VAL_STRING( args, "command" );
char *esc = g_markup_escape_text( cmd, -1 );
char *err = NULL;
const char *error = NULL;
c_s = purple_cmd_do_command( pc, cmd, esc, &err );
if( c_s != PURPLE_CMD_STATUS_OK && (!err || !*err) )
switch( c_s )
{
case PURPLE_CMD_STATUS_FAILED :
error = "Command failed";
break;
case PURPLE_CMD_STATUS_NOT_FOUND :
error = "Command not found";
break;
case PURPLE_CMD_STATUS_WRONG_ARGS:
error = "Bad command arguments";
break;
case PURPLE_CMD_STATUS_WRONG_PRPL:
error = "Command not valid for this IM protocol";
break;
case PURPLE_CMD_STATUS_WRONG_TYPE:
error = "Command not valid in this conversation";
break;
default:
error = "Unknown command error";
}
xmlnode *rval = xnode_new( "alist" );
AL_PTR ( rval, "conv-uid" , pc );
AL_STR ( rval, "conv-name" , purple_conversation_get_name(pc) );
AL_ENUM( rval, "command-status", c_s , ":cmd-status" );
AL_STR ( rval, "command-error" , err ? err : error );
AL_STR ( rval, "command-line" , cmd );
g_free ( err );
g_free ( esc );
sexp_val_free( args );
fprintf(stderr, "(elim-debug leaving _h_elim_command)");
return response_value( 0, id, name, rval );
}
xmlnode * _h_elim_add_chat( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
elim_ping();
const char *aname = ALIST_VAL_STR ( args, "account-name" );
const char *proto = ALIST_VAL_STR ( args, "im-protocol" );
const char *alias = ALIST_VAL_STR ( args, "chat-alias" );
gpointer auid = ALIST_VAL_PTR ( args, "account-uid" );
GHashTable *opts = ALIST_VAL_ALIST( args, "chat-options" );
GHashTable *options = __ghash_str_sexp__str_str( opts );
PurpleAccount *acct =
auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto );
if( !acct )
{
sexp_val_free( args );
return response_error( ENXIO, id, name, "unknown account" );
}
// cook up a chat node. if it's already on our buddy list, uncook it
// and use the old one instead (name should be unique per account
// so the operation is reasonable - we cannot supply a name as this
// parameter can be delegated to the plugin to generate automatically):
// this will trigger a new_node call, and possibly a remove call
PurpleChat *chat = purple_chat_new( acct, alias, options );
const char *chn = purple_chat_get_name( chat );
PurpleChat *ch_2 = purple_blist_find_chat( acct, chn );
if( ch_2 )
{
fprintf( stderr, "(elim-debug chat already exists)\n" );
purple_blist_remove_chat( chat );
chat = ch_2;
chn = purple_chat_get_name( chat );
purple_blist_alias_chat( chat, alias );
}
fprintf( stderr, "(elim-debug adding chat to blist)\n" );
purple_blist_add_chat( chat, NULL, NULL );
// if we have a conversation already, prod the client to show it
fprintf( stderr, "(elim-debug looking for conversation)\n" );
PurpleConversation *conv =
purple_find_conversation_with_account( PURPLE_CONV_TYPE_CHAT, chn, acct );
if( conv )
purple_conversation_present( conv );
xmlnode *rval = xnode_new( "alist" );
AL_STR( rval, "account-name", purple_account_get_username (acct) );
AL_STR( rval, "im-protocol" , purple_account_get_protocol_id(acct) );
AL_PTR( rval, "account-uid" , acct );
AL_STR( rval, "chat-name" , chn );
if( conv )
{
PurpleConversationType pct = purple_conversation_get_type ( conv );
PurpleConnectionFlags pcf = purple_conversation_get_features( conv );
AL_PTR ( rval, "conv-uid" , conv );
AL_STR ( rval, "conv-name" , purple_conversation_get_name (conv) );
AL_STR ( rval, "conv-title" , purple_conversation_get_title(conv) );
AL_ENUM( rval, "conv-type" , pct, ":conversation-type" );
AL_ENUM( rval, "conv-features", pcf, ":connection-flags" );
}
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
