pidgin/pidgin

facebook: fb_api_cb_contacts: Make all the other fields optional too

2016-10-22, dequis
6917682375dd
facebook: fb_api_cb_contacts: Make all the other fields optional too

Fixes "No matches for $.represented_profile.id" errors

Previously, hugePictureUrl was made optional. Now someone complains about
represented_profile being missing, replaced with a null. To be honest I'm
worried about what kind of bug might be breaking things so subtly on the
server side, but well, it's not my job.

This will result in some friends with missing represented_profile not
being included in the contact list, because we're missing rather
essential information. But better than not being able to log in.
/* purple
*
* Purple 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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#ifndef PURPLE_CIPHER_H
#define PURPLE_CIPHER_H
/**
* SECTION:cipher
* @section_id: libpurple-cipher
* @short_description: <filename>cipher.h</filename>
* @title: Cipher and Hash API
*/
#include <glib.h>
#include <glib-object.h>
#include <string.h>
#define PURPLE_TYPE_CIPHER (purple_cipher_get_type())
#define PURPLE_CIPHER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), PURPLE_TYPE_CIPHER, PurpleCipher))
#define PURPLE_CIPHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), PURPLE_TYPE_CIPHER, PurpleCipherClass))
#define PURPLE_IS_CIPHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), PURPLE_TYPE_CIPHER))
#define PURPLE_IS_CIPHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), PURPLE_TYPE_CIPHER))
#define PURPLE_CIPHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), PURPLE_TYPE_CIPHER, PurpleCipherClass))
typedef struct _PurpleCipher PurpleCipher;
typedef struct _PurpleCipherClass PurpleCipherClass;
#define PURPLE_TYPE_HASH (purple_hash_get_type())
#define PURPLE_HASH(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), PURPLE_TYPE_HASH, PurpleHash))
#define PURPLE_HASH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), PURPLE_TYPE_HASH, PurpleHashClass))
#define PURPLE_IS_HASH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), PURPLE_TYPE_HASH))
#define PURPLE_IS_HASH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), PURPLE_TYPE_HASH))
#define PURPLE_HASH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), PURPLE_TYPE_HASH, PurpleHashClass))
typedef struct _PurpleHash PurpleHash;
typedef struct _PurpleHashClass PurpleHashClass;
/**
* PurpleCipherBatchMode:
* @PURPLE_CIPHER_BATCH_MODE_ECB: Electronic Codebook Mode
* @PURPLE_CIPHER_BATCH_MODE_CBC: Cipher Block Chaining Mode
*
* Modes for batch encrypters
*/
typedef enum {
PURPLE_CIPHER_BATCH_MODE_ECB,
PURPLE_CIPHER_BATCH_MODE_CBC
} PurpleCipherBatchMode;
/**
* PurpleCipher:
*
* Purple Cipher is an opaque data structure and should not be used directly.
*/
struct _PurpleCipher {
GObject gparent;
};
struct _PurpleCipherClass {
GObjectClass parent_class;
/** The reset function */
void (*reset)(PurpleCipher *cipher);
/** The reset state function */
void (*reset_state)(PurpleCipher *cipher);
/** The set initialization vector function */
void (*set_iv)(PurpleCipher *cipher, guchar *iv, size_t len);
/** The append data function */
void (*append)(PurpleCipher *cipher, const guchar *data, size_t len);
/** The digest function */
gboolean (*digest)(PurpleCipher *cipher, guchar digest[], size_t len);
/** The get digest size function */
size_t (*get_digest_size)(PurpleCipher *cipher);
/** The encrypt function */
ssize_t (*encrypt)(PurpleCipher *cipher, const guchar input[], size_t in_len, guchar output[], size_t out_size);
/** The decrypt function */
ssize_t (*decrypt)(PurpleCipher *cipher, const guchar input[], size_t in_len, guchar output[], size_t out_size);
/** The set salt function */
void (*set_salt)(PurpleCipher *cipher, const guchar *salt, size_t len);
/** The set key function */
void (*set_key)(PurpleCipher *cipher, const guchar *key, size_t len);
/** The get key size function */
size_t (*get_key_size)(PurpleCipher *cipher);
/** The set batch mode function */
void (*set_batch_mode)(PurpleCipher *cipher, PurpleCipherBatchMode mode);
/** The get batch mode function */
PurpleCipherBatchMode (*get_batch_mode)(PurpleCipher *cipher);
/** The get block size function */
size_t (*get_block_size)(PurpleCipher *cipher);
/*< private >*/
void (*_purple_reserved1)(void);
void (*_purple_reserved2)(void);
void (*_purple_reserved3)(void);
void (*_purple_reserved4)(void);
};
/**
* PurpleHash:
*
* Purple Hash is an opaque data structure and should not be used directly.
*/
struct _PurpleHash {
GObject gparent;
};
struct _PurpleHashClass {
GObjectClass parent_class;
/** The reset function */
void (*reset)(PurpleHash *hash);
/** The reset state function */
void (*reset_state)(PurpleHash *hash);
/** The append data function */
void (*append)(PurpleHash *hash, const guchar *data, size_t len);
/** The digest function */
gboolean (*digest)(PurpleHash *hash, guchar digest[], size_t len);
/** The get digest size function */
size_t (*get_digest_size)(PurpleHash *hash);
/** The get block size function */
size_t (*get_block_size)(PurpleHash *hash);
/*< private >*/
void (*_purple_reserved1)(void);
void (*_purple_reserved2)(void);
void (*_purple_reserved3)(void);
void (*_purple_reserved4)(void);
};
G_BEGIN_DECLS
/*****************************************************************************/
/* PurpleCipher API */
/*****************************************************************************/
/**
* purple_cipher_get_type:
*
* Returns: The #GType for the Cipher object.
*/
GType purple_cipher_get_type(void);
/**
* purple_cipher_reset:
* @cipher: The cipher
*
* Resets a cipher to it's default value
* Note: If you have set an IV you will have to set it after resetting
*/
void purple_cipher_reset(PurpleCipher *cipher);
/**
* purple_cipher_reset_state:
* @cipher: The cipher
*
* Resets a cipher state to it's default value, but doesn't touch stateless
* configuration.
*
* That means, IV and digest will be wiped out, but keys, ops or salt
* will remain untouched.
*/
void purple_cipher_reset_state(PurpleCipher *cipher);
/**
* purple_cipher_set_iv:
* @cipher: The cipher
* @iv: The initialization vector to set
* @len: The len of the IV
*
* Sets the initialization vector for a cipher
* Note: This should only be called right after a cipher is created or reset
*/
void purple_cipher_set_iv(PurpleCipher *cipher, guchar *iv, size_t len);
/**
* purple_cipher_append:
* @cipher: The cipher
* @data: The data to append
* @len: The length of the data
*
* Appends data to the cipher context
*/
void purple_cipher_append(PurpleCipher *cipher, const guchar *data, size_t len);
/**
* purple_cipher_digest:
* @cipher: The cipher
* @digest: The return buffer for the digest
* @len: The length of the buffer
*
* Digests a cipher context
*/
gboolean purple_cipher_digest(PurpleCipher *cipher, guchar digest[], size_t len);
/**
* purple_cipher_digest_to_str:
* @cipher: The cipher
* @digest_s: The return buffer for the string digest
* @len: The length of the buffer
*
* Converts a guchar digest into a hex string
*/
gboolean purple_cipher_digest_to_str(PurpleCipher *cipher, gchar digest_s[], size_t len);
/**
* purple_cipher_get_digest_size:
* @cipher: The cipher whose digest size to get
*
* Gets the digest size of a cipher
*
* Returns: The digest size of the cipher
*/
size_t purple_cipher_get_digest_size(PurpleCipher *cipher);
/**
* purple_cipher_encrypt:
* @cipher: The cipher
* @input: The data to encrypt
* @in_len: The length of the data
* @output: The output buffer
* @out_size: The size of the output buffer
*
* Encrypts data using the cipher
*
* Returns: A length of data that was outputed or -1, if failed
*/
ssize_t purple_cipher_encrypt(PurpleCipher *cipher, const guchar input[], size_t in_len, guchar output[], size_t out_size);
/**
* purple_cipher_decrypt:
* @cipher: The cipher
* @input: The data to encrypt
* @in_len: The length of the returned value
* @output: The output buffer
* @out_size: The size of the output buffer
*
* Decrypts data using the cipher
*
* Returns: A length of data that was outputed or -1, if failed
*/
ssize_t purple_cipher_decrypt(PurpleCipher *cipher, const guchar input[], size_t in_len, guchar output[], size_t out_size);
/**
* purple_cipher_set_salt:
* @cipher: The cipher whose salt to set
* @salt: The salt
* @len: The length of the salt
*
* Sets the salt on a cipher
*/
void purple_cipher_set_salt(PurpleCipher *cipher, const guchar *salt, size_t len);
/**
* purple_cipher_set_key:
* @cipher: The cipher whose key to set
* @key: The key
* @len: The size of the key
*
* Sets the key on a cipher
*/
void purple_cipher_set_key(PurpleCipher *cipher, const guchar *key, size_t len);
/**
* purple_cipher_get_key_size:
* @cipher: The cipher whose key size to get
*
* Gets the size of the key if the cipher supports it
*
* Returns: The size of the key
*/
size_t purple_cipher_get_key_size(PurpleCipher *cipher);
/**
* purple_cipher_set_batch_mode:
* @cipher: The cipher whose batch mode to set
* @mode: The batch mode under which the cipher should operate
*
* Sets the batch mode of a cipher
*/
void purple_cipher_set_batch_mode(PurpleCipher *cipher, PurpleCipherBatchMode mode);
/**
* purple_cipher_get_batch_mode:
* @cipher: The cipher whose batch mode to get
*
* Gets the batch mode of a cipher
*
* Returns: The batch mode under which the cipher is operating
*/
PurpleCipherBatchMode purple_cipher_get_batch_mode(PurpleCipher *cipher);
/**
* purple_cipher_get_block_size:
* @cipher: The cipher whose block size to get
*
* Gets the block size of a cipher
*
* Returns: The block size of the cipher
*/
size_t purple_cipher_get_block_size(PurpleCipher *cipher);
/*****************************************************************************/
/* PurpleHash API */
/*****************************************************************************/
/**
* purple_hash_get_type:
*
* Returns: The #GType for the Hash object.
*/
GType purple_hash_get_type(void);
/**
* purple_hash_reset:
* @hash: The hash
*
* Resets a hash to it's default value
* Note: If you have set an IV you will have to set it after resetting
*/
void purple_hash_reset(PurpleHash *hash);
/**
* purple_hash_reset_state:
* @hash: The hash
*
* Resets a hash state to it's default value, but doesn't touch stateless
* configuration.
*
* That means, IV and digest will be wiped out, but keys, ops or salt
* will remain untouched.
*/
void purple_hash_reset_state(PurpleHash *hash);
/**
* purple_hash_append:
* @hash: The hash
* @data: The data to append
* @len: The length of the data
*
* Appends data to the hash context
*/
void purple_hash_append(PurpleHash *hash, const guchar *data, size_t len);
/**
* purple_hash_digest:
* @hash: The hash
* @digest: The return buffer for the digest
* @len: The length of the buffer
*
* Digests a hash context
*/
gboolean purple_hash_digest(PurpleHash *hash, guchar digest[], size_t len);
/**
* purple_hash_digest_to_str:
* @hash: The hash
* @digest_s: The return buffer for the string digest
* @len: The length of the buffer
*
* Converts a guchar digest into a hex string
*/
gboolean purple_hash_digest_to_str(PurpleHash *hash, gchar digest_s[], size_t len);
/**
* purple_hash_get_digest_size:
* @hash: The hash whose digest size to get
*
* Gets the digest size of a hash
*
* Returns: The digest size of the hash
*/
size_t purple_hash_get_digest_size(PurpleHash *hash);
/**
* purple_hash_get_block_size:
* @hash: The hash whose block size to get
*
* Gets the block size of a hash
*
* Returns: The block size of the hash
*/
size_t purple_hash_get_block_size(PurpleHash *hash);
G_END_DECLS
#endif /* PURPLE_CIPHER_H */