#define PRIVKEY_PATH [[[adium.loginController userDirectory] stringByAppendingPathComponent:@"otr.private_key"] UTF8String]

#define STORE_PATH [[[adium.loginController userDirectory] stringByAppendingPathComponent:@"otr.fingerprints"] UTF8String]

/* OTRL_POLICY_MANUAL doesn't let us respond to other users' automatic attempts at encryption.

* If either user has OTR set to Automatic, an OTR session should be begun; without this modified

@implementation AdiumOTREncryption

/* We'll only use the one OtrlUserState. */

static AdiumOTREncryption *adiumOTREncryption = nil;

void send_default_query_to_chat(AIChat *inChat);

void disconnect_from_chat(AIChat *inChat);

void disconnect_from_context(ConnContext *context);

TrustLevel otrg_plugin_context_to_trust(ConnContext *context);

- (id)init

{

//Singleton

if ((self = [super init])) {

adiumOTREncryption = self;

//Wait for Adium to finish launching to prepare encryption so that accounts will be loaded

[[NSNotificationCenter defaultCenter] addObserver:self

}

return self;

[[NSNotificationCenter defaultCenter] addObserver:self

[[NSNotificationCenter defaultCenter] addObserver:self

[[NSNotificationCenter defaultCenter] addObserver:self

[[NSNotificationCenter defaultCenter] addObserver:self

//Add the Encryption preferences

OTRPrefs = [(ESOTRPreferences *)[ESOTRPreferences preferencePane] retain];

}

/*

* @brief Return an NSDictionary* describing a ConnContext.

* @"who" : The UID of the remote user *

* @result The dictinoary

*/

{

if (!context) return nil;

if (!fprint || !(fprint->fingerprint)) return nil;

AIAccount *account;

switch (level) {

case TRUST_NOT_PRIVATE:

encryptionStatus = EncryptionStatus_None;

break;

break;

}

otrl_privkey_fingerprint(otrg_get_userstate(), our_hash,

context->accountname, context->protocol);

otrl_privkey_hash_to_human(their_hash, fprint->fingerprint);

unsigned char *sessionid;

BOOL sess1_outgoing = (context->sessionid_half == OTRL_SESSIONID_FIRST_HALF_BOLD);

size_t idhalflen = (context->sessionid_len) / 2;

/* Make a human-readable version of the sessionid (in two parts) */

sessionid = context->sessionid;

account = [adium.accountController accountWithInternalObjectID:[NSString stringWithUTF8String:context->accountname]];

@"EncryptionStatus": @(encryptionStatus),

@"AIAccount" : account,

@"who": [NSString stringWithUTF8String:context->username],

return securityDetailsDict;

}

{

return [adium.accountController accountWithInternalObjectID:[NSString stringWithUTF8String:accountID]];

}

{

return [adium.accountController serviceWithUniqueID:[NSString stringWithUTF8String:serviceID]];

}

{

return [adium.contactController contactWithService:serviceFromServiceID(serviceID)

}

{

return contactFromInfo(context->accountname, context->protocol, context->username);

}

{

AIListContact *listContact = contactForContext(context);

AIChat *chat = [adium.chatController existingChatWithContact:listContact];

if (!chat) {

chat = [adium.chatController chatWithContact:listContact];

}

}

{

switch (pref) {

case EncryptedChat_Never:

policy = OTRL_POLICY_NEVER;

}

//Return the ConnContext for a Conversation, or NULL if none exists

{

AIAccount *account;

ConnContext *context;

/* Do nothing if this isn't an IM conversation */

if (chat.isGroupChat) return NULL;

}

/* What level of trust do we have in the privacy of this ConnContext? */

{

TrustLevel level = TRUST_NOT_PRIVATE;

return level;

}

/* Return the OTR policy for the given context. */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

return ret;

}

{

static BOOL alreadyGenerating = FALSE;

static dispatch_queue_t keyGenerationQueue = NULL;

/* Create a private key for the given accountname/protocol if

* desired. */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

otrg_plugin_create_privkey(accountname, protocol);

* If you return 1, messages such as heartbeats or other

* notifications may be sent to the user, which could result in "not

* logged in" errors if you're wrong. */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

/* Send the given IM to the given recipient from the given

* accountname/protocol. */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

[adium.contentController sendRawMessage:[NSString stringWithUTF8String:message]

[pool release];

}

/* When the list of ConnContexts changes (including a change in

* state), this is called so the UI can be updated. */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

/* Return a newly allocated string containing a human-friendly

* representation for the given account */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

}

/* Deallocate a string returned by account_name */

{

if (account_display_name)

free((char *)account_display_name);

/* A new fingerprint for the given user has been received. */

{

ConnContext *context;

context = otrl_context_find(us, username, accountname,

}

/* The list of known fingerprints has changed. Write them to disk. */

{

otrg_plugin_write_fingerprints();

}

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

}

/* A ConnContext has left a secure state. */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

/* We have completed an authentication, using the D-H keys we

* already knew. is_reply indicates whether we initiated the AKE. */

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

if (is_reply == 0) {

AILog(@"Still secure...");

}

* of a particular message. The latter is useful, for example, for

* protocols like XMPP (Jabber) that do not require fragmentation at all.

*/

{

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

/* Values from http://www.cypherpunks.ca/otr/UPGRADING-libotr-3.1.0.txt */

static NSDictionary *maxSizeByServiceClassDict = nil;

/* This will return 0 if we don't know (unknown protocol) or don't need it (Jabber),

* which will disable fragmentation.

return ret;

}

{

NSString *errorMessage = nil;

break;

case OTRL_ERRCODE_MSG_NOT_IN_PRIVATE:

errorMessage = AILocalizedStringFromTableInBundle(@"Sent encrypted message to somebody who is not in a mutual OTR session", nil, [NSBundle bundleForClass:[AdiumOTREncryption class]], nil);

case OTRL_ERRCODE_MSG_UNREADABLE:

errorMessage = AILocalizedStringFromTableInBundle(@"Sent an unreadable encrypted message", nil, [NSBundle bundleForClass:[AdiumOTREncryption class]], nil);

case OTRL_ERRCODE_MSG_MALFORMED:

errorMessage = AILocalizedStringFromTableInBundle(@"Message sent is malformed", nil, [NSBundle bundleForClass:[AdiumOTREncryption class]], nil);

default:

return NULL;

}

return message_str;

}

{

}

{

const char *prefix_str = strdup([AILocalizedStringFromTableInBundle(@"[resent]", @"Prefix used by OTR for resent messages", [NSBundle bundleForClass:[AdiumOTREncryption class]], nil) UTF8String]);

return prefix_str;

}

{

}

static dispatch_source_t timer = NULL;

timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());

dispatch_source_set_event_handler(timer, ^{

otrl_message_poll(otrg_plugin_userstate, &ui_ops, opdata);

dispatch_resume(timer);

}

}

static void

{

AIListContact *listContact = contactForContext(context);

AIChat *chat = chatForContext(context);

withSource:listContact

destination:chat.account

date:nil

autoreply:NO];

[adium.contentController receiveContentObject:messageObject];

break;

case OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE:

AILogWithSignature(@"Received an OTR message for a different instance. We will silently ignore it: %s", message);

break;

case OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD:

case OTRL_MSGEVENT_LOG_HEARTBEAT_SENT:

AILogWithSignature(@"I'm still alive");

break;

}

case OTRL_MSGEVENT_CONNECTION_ENDED: {

if (!chat) chat = [adium.chatController chatWithContact:listContact];

[adium.contentController displayEvent:[[AIHTMLDecoder decodeHTML:localizedMessage] string]

ofType:@"encryption"

inChat:chat];

}

}

{

otrl_instag_generate(otrg_plugin_userstate, INSTAG_PATH, accountname, protocol);

}

static void

handle_smp_event_cb(void *opdata, OtrlSMPEvent smp_event, ConnContext *context, unsigned short progress_percent, char *question)

{

[questionController showWindow:nil];

[questionController.window orderFront:nil];

}

case OTRL_SMPEVENT_CHEATED:

case OTRL_SMPEVENT_ERROR:

inChat:chat];

otrg_plugin_write_fingerprints();

otrg_ui_update_keylist();

}

default:

timer_control_cb,

};

- (void)willSendContentMessage:(AIContentMessage *)inContentMessage

{

{

if (inSecureMessaging) {

send_default_query_to_chat(inChat);

} else {

disconnect_from_chat(inChat);

}

#pragma mark -

{

//Note that we pass a name for display, not internal usage

char *msg = otrl_proto_default_query_msg([inChat.account.formattedUID UTF8String],

/* Disconnect a context, sending a notice to the other side, if

* appropriate. */

{

otrl_message_disconnect(otrg_plugin_userstate, &ui_ops, NULL,

context->accountname, context->protocol, context->username, OTRL_INSTAG_RECENT);

gone_insecure_cb(NULL, context);

}

{

disconnect_from_context(contextForChat(inChat));

}

#pragma mark -

/* Forget a fingerprint */

{

ConnContext *context;

otrg_plugin_write_fingerprints();

}

{

otrl_privkey_write_fingerprints(otrg_plugin_userstate, STORE_PATH);

otrg_ui_update_fingerprint();

}

{

[adiumOTREncryption prefsShouldUpdatePrivateKeyList];

}

{

[adiumOTREncryption prefsShouldUpdateFingerprintsList];

}

{

return otrg_plugin_userstate;

}