/**
* gwy_interpolation_interpolate_2d:
* @x: X-position in interval [0,1) to get value at.
* @y: Y-position in interval [0,1) to get value at.
* @rowstride: Row stride of @coeff.
* @coeff: Array of support-length-squared size with interpolation coefficients
* (that are equal to data values for an interpolating basis).
* @interpolation: Interpolation type to use.
*
* Interpolates a signle data point in two dimensions.
*
* Returns: Interpolated value.
*
* Since: 2.2
**/
gdouble
gwy_interpolation_interpolate_2d(gdouble x,
gdouble y,
gint rowstride,
const gdouble *coeff,
GwyInterpolationType interpolation)
{
gdouble *wx, *wy;
gint i, j, suplen;
gdouble v, vx;
g_return_val_if_fail(x >= 0.0 && x <= 1.0 && y >= 0.0 && y <= 1.0, 0.0);
suplen = gwy_interpolation_get_support_size(interpolation);
if (G_UNLIKELY(suplen == 0))
return 0.0;
g_return_val_if_fail(suplen > 0, 0.0);
wx = g_newa(gdouble, suplen);
wy = g_newa(gdouble, suplen);
gwy_interpolation_get_weights(x, interpolation, wx);
gwy_interpolation_get_weights(y, interpolation, wy);
v = 0.0;
for (i = 0; i < suplen; i++) {
vx = 0.0;
for (j = 0; j < suplen; j++)
vx += coeff[i*rowstride + j]*wx[j];
v += wy[i]*vx;
}
return v;
}
/* send login packet to QQ server */
static void qq_send_packet_login(PurpleConnection *gc, guint8 token_length, guint8 *token)
{
qq_data *qd;
guint8 *buf, *cursor, *raw_data, *encrypted_data;
guint16 seq_ret;
gint encrypted_len, bytes;
gint pos;
qd = (qq_data *) gc->proto_data;
buf = g_newa(guint8, MAX_PACKET_SIZE);
raw_data = g_newa(guint8, QQ_LOGIN_DATA_LENGTH);
encrypted_data = g_newa(guint8, QQ_LOGIN_DATA_LENGTH + 16); /* 16 bytes more */
qd->inikey = _gen_login_key();
/* now generate the encrypted data
* 000-015 use pwkey as key to encrypt empty string */
qq_crypt(ENCRYPT, (guint8 *) "", 0, qd->pwkey, raw_data, &encrypted_len);
/* 016-016 */
raw_data[16] = 0x00;
/* 017-020, used to be IP, now zero */
*((guint32 *) (raw_data + 17)) = 0x00000000;
/* 021-022, used to be port, now zero */
*((guint16 *) (raw_data + 21)) = 0x0000;
/* 023-051, fixed value, unknown */
g_memmove(raw_data + 23, login_23_51, 29);
/* 052-052, login mode */
raw_data[52] = qd->login_mode;
/* 053-068, fixed value, maybe related to per machine */
g_memmove(raw_data + 53, login_53_68, 16);
/* 069, login token length */
raw_data[69] = token_length;
pos = 70;
/* 070-093, login token, normally 24 bytes */
g_memmove(raw_data + pos, token, token_length);
pos += token_length;
/* 100 bytes unknown */
g_memmove(raw_data + pos, login_100_bytes, 100);
pos += 100;
/* all zero left */
memset(raw_data+pos, 0, QQ_LOGIN_DATA_LENGTH - pos);
qq_crypt(ENCRYPT, raw_data, QQ_LOGIN_DATA_LENGTH, qd->inikey, encrypted_data, &encrypted_len);
cursor = buf;
bytes = 0;
bytes += _create_packet_head_seq(buf, &cursor, gc, QQ_CMD_LOGIN, TRUE, &seq_ret);
bytes += create_packet_dw(buf, &cursor, qd->uid);
bytes += create_packet_data(buf, &cursor, qd->inikey, QQ_KEY_LENGTH);
bytes += create_packet_data(buf, &cursor, encrypted_data, encrypted_len);
bytes += create_packet_b(buf, &cursor, QQ_PACKET_TAIL);
if (bytes == (cursor - buf)) /* packet creation OK */
_qq_send_packet(gc, buf, bytes, QQ_CMD_LOGIN);
else
purple_debug(PURPLE_DEBUG_ERROR, "QQ", "Fail create login packet\n");
}
static gint send_room_cmd(PurpleConnection *gc, guint8 room_cmd, guint32 room_id,
guint8 *data, gint data_len, UPDCLS update_class, guint32 ship32)
{
qq_data *qd;
guint8 *buf;
gint buf_len;
guint8 *encrypted;
gint encrypted_len;
gint bytes_sent;
guint16 seq;
g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1);
qd = (qq_data *) gc->proto_data;
buf = g_newa(guint8, MAX_PACKET_SIZE);
memset(buf, 0, MAX_PACKET_SIZE);
/* encap room_cmd and room id to buf*/
buf_len = 0;
buf_len += qq_put8(buf + buf_len, room_cmd);
if (room_id != 0) {
/* id 0 is for QQ Demo Group, now they are closed*/
buf_len += qq_put32(buf + buf_len, room_id);
}
if (data != NULL && data_len > 0) {
buf_len += qq_putdata(buf + buf_len, data, data_len);
}
qd->send_seq++;
seq = qd->send_seq;
/* Encrypt to encrypted with session_key */
/* at most 17 bytes more */
encrypted = g_newa(guint8, buf_len + 17);
encrypted_len = qq_encrypt(encrypted, buf, buf_len, qd->session_key);
if (encrypted_len < 16) {
purple_debug_error("QQ_ENCRYPT", "Error len %d: [%05d] %s (0x%02X)\n",
encrypted_len, seq, qq_get_room_cmd_desc(room_cmd), room_cmd);
return -1;
}
bytes_sent = packet_send_out(gc, QQ_CMD_ROOM, seq, encrypted, encrypted_len);
#if 1
/* qq_show_packet("send_room_cmd", buf, buf_len); */
purple_debug_info("QQ",
"<== [%05d] %s (0x%02X) to room %d, datalen %d\n",
seq, qq_get_room_cmd_desc(room_cmd), room_cmd, room_id, buf_len);
#endif
qq_trans_add_room_cmd(gc, seq, room_cmd, room_id, encrypted, encrypted_len,
update_class, ship32);
return bytes_sent;
}
gboolean
peas_gi_method_call (GObject *instance,
GICallableInfo *func_info,
GType iface_type,
const gchar *method_name,
GIArgument *args,
GIArgument *return_value)
{
gint n_args;
guint n_in_args, n_out_args;
GIArgument *in_args, *out_args;
gboolean ret = TRUE;
GError *error = NULL;
g_return_val_if_fail (G_IS_OBJECT (instance), FALSE);
g_return_val_if_fail (func_info != NULL, FALSE);
g_return_val_if_fail (G_TYPE_IS_INTERFACE (iface_type), FALSE);
g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (instance, iface_type),
FALSE);
g_return_val_if_fail (method_name != NULL, FALSE);
n_args = g_callable_info_get_n_args (func_info);
g_return_val_if_fail (n_args >= 0, FALSE);
n_in_args = 0;
n_out_args = 0;
in_args = g_newa (GIArgument, n_args + 1);
out_args = g_newa (GIArgument, n_args);
peas_gi_split_in_and_out_arguments (func_info, args,
in_args+1, &n_in_args,
out_args, &n_out_args);
/* Set the object as the first argument for the method. */
in_args[0].v_pointer = instance;
n_in_args++;
g_debug ("Calling '%s.%s' on '%p'",
g_type_name (iface_type), method_name, instance);
ret = g_function_info_invoke (func_info, in_args, n_in_args, out_args,
n_out_args, return_value, &error);
if (!ret)
{
g_warning ("Error while calling '%s.%s': %s",
g_type_name (iface_type), method_name, error->message);
g_error_free (error);
}
return ret;
}
/**
* gwy_interpolation_get_dval_of_equidists:
* @x: Possibily noninteger position in @data to get value at.
* @data: Array of 4 values to interpolate between (see below).
* @interpolation: Interpolation type to use.
*
* Computes interpolated value from 2 or 4 equidistant values.
*
* For %GWY_INTERPOLATION_NONE no @data value is actually used, and zero is
* returned.
*
* For %GWY_INTERPOLATION_ROUND or %GWY_INTERPOLATION_LINEAR
* it is enough to set middle two @data values, that to use @data in format
* {0, data[i], data[i+1], 0} and function computes value at data[i+x]
* (the outer values are not used).
*
* For four value interpolations you have to prepare @data as
* {data[i-1], data[i], data[i+1], data[i+2]} and function again
* returns value at data[i+x].
*
* Interpolation with non-interpolating bases are silently replaced with an
* interpolating function with the same support size. See
* gwy_interpolation_interpolate_1d() for a function interpolating from
* interpolation coefficients.
*
* Returns: Interpolated value.
**/
gdouble
gwy_interpolation_get_dval_of_equidists(gdouble x,
gdouble *data,
GwyInterpolationType interpolation)
{
gint l;
gdouble *w;
gdouble rest;
x += 1.0;
l = floor(x);
rest = x - (gdouble)l;
g_return_val_if_fail(x >= 1 && x < 2, 0.0);
if (rest == 0)
return data[l];
switch (interpolation) {
case GWY_INTERPOLATION_NONE:
return 0.0;
break;
case GWY_INTERPOLATION_ROUND:
case GWY_INTERPOLATION_LINEAR:
w = g_newa(gdouble, 2);
gwy_interpolation_get_weights(rest, interpolation, w);
return w[0]*data[l] + w[1]*data[l + 1];
break;
/* One cannot do B-spline and o-MOMS this way. Read e.g.
* `Interpolation Revisited' by Philippe Thevenaz for explanation.
* Replace them with Key. */
case GWY_INTERPOLATION_BSPLINE:
case GWY_INTERPOLATION_OMOMS:
interpolation = GWY_INTERPOLATION_KEY;
case GWY_INTERPOLATION_KEY:
case GWY_INTERPOLATION_NNA:
case GWY_INTERPOLATION_SCHAUM:
w = g_newa(gdouble, 4);
gwy_interpolation_get_weights(rest, interpolation, w);
return w[0]*data[l - 1] + w[1]*data[l]
+ w[2]*data[l + 1] + w[3]*data[l + 2];
break;
default:
g_return_val_if_reached(0.0);
break;
}
}
/**
* peas_extension_set_call_valist: (skip)
* @set: A #PeasExtensionSet.
* @method_name: the name of the method that should be called.
* @va_args: the arguments for the method.
*
* Call a method on all the #PeasExtension instances contained in @set.
*
* See peas_extension_call_valist() for more information.
*
* Deprecated: 1.2. Use peas_extension_set_foreach() instead.
*
* Return value: %TRUE on successful call.
*/
gboolean
peas_extension_set_call_valist (PeasExtensionSet *set,
const gchar *method_name,
va_list va_args)
{
GICallableInfo *callable_info;
GIArgument *args;
gint n_args;
g_return_val_if_fail (PEAS_IS_EXTENSION_SET (set), FALSE);
g_return_val_if_fail (method_name != NULL, FALSE);
callable_info = peas_gi_get_method_info (set->priv->exten_type, method_name);
/* Already warned */
if (callable_info == NULL)
return FALSE;
n_args = g_callable_info_get_n_args (callable_info);
g_return_val_if_fail (n_args >= 0, FALSE);
args = g_newa (GIArgument, n_args);
peas_gi_valist_to_arguments (callable_info, va_args, args, NULL);
g_base_info_unref ((GIBaseInfo *) callable_info);
return peas_extension_set_callv (set, method_name, args);
}
/**
* gwy_inventory_restore_order:
* @inventory: An inventory.
*
* Assures an inventory is sorted.
**/
void
gwy_inventory_restore_order(GwyInventory *inventory)
{
guint i;
gint *new_order;
g_return_if_fail(GWY_IS_INVENTORY(inventory));
g_return_if_fail(!inventory->is_const);
g_return_if_fail(inventory->item_type.compare);
if (inventory->is_sorted)
return;
/* Make sure old order is remembered in @idx */
if (inventory->needs_reindex)
gwy_inventory_reindex(inventory);
g_array_sort_with_data(inventory->ridx,
(GCompareDataFunc)gwy_inventory_compare_indices,
inventory);
new_order = g_newa(gint, inventory->items->len);
/* Fill new_order with indices: new_order[new_position] = old_position */
for (i = 0; i < inventory->ridx->len; i++)
new_order[i] = g_array_index(inventory->idx, guint,
g_array_index(inventory->ridx, guint, i));
inventory->needs_reindex = TRUE;
inventory->is_sorted = TRUE;
g_signal_emit(inventory, gwy_inventory_signals[ITEMS_REORDERED], 0,
new_order);
}
/* send IM to a group */
void qq_send_packet_group_im(GaimConnection *gc, qq_group *group, const gchar *msg)
{
gint data_len, bytes;
guint8 *raw_data, *cursor, *send_im_tail;
guint16 msg_len;
gchar *msg_filtered;
g_return_if_fail(group != NULL && msg != NULL);
msg_filtered = gaim_markup_strip_html(msg);
msg_len = strlen(msg_filtered);
data_len = 7 + msg_len + QQ_SEND_IM_AFTER_MSG_LEN;
raw_data = g_newa(guint8, data_len);
cursor = raw_data;
bytes = 0;
bytes += create_packet_b(raw_data, &cursor, QQ_GROUP_CMD_SEND_MSG);
bytes += create_packet_dw(raw_data, &cursor, group->internal_group_id);
bytes += create_packet_w(raw_data, &cursor, msg_len + QQ_SEND_IM_AFTER_MSG_LEN);
bytes += create_packet_data(raw_data, &cursor, (guint8 *) msg_filtered, msg_len);
send_im_tail = qq_get_send_im_tail(NULL, NULL, NULL,
FALSE, FALSE, FALSE,
QQ_SEND_IM_AFTER_MSG_LEN);
bytes += create_packet_data(raw_data, &cursor, send_im_tail, QQ_SEND_IM_AFTER_MSG_LEN);
g_free(send_im_tail);
g_free(msg_filtered);
if (bytes == data_len) /* create OK */
qq_send_group_cmd(gc, group, raw_data, data_len);
else
gaim_debug(GAIM_DEBUG_ERROR, "QQ",
"Fail creating group_im packet, expect %d bytes, build %d bytes\n", data_len, bytes);
}
static void
gwy_layer_basic_connect_fixed(GwyLayerBasic *basic_layer)
{
GwyDataViewLayer *layer;
const gchar *prefix;
gchar *detailed_signal;
guint len;
layer = GWY_DATA_VIEW_LAYER(basic_layer);
if (!layer->data || !basic_layer->fixed_key)
return;
prefix = g_quark_to_string(basic_layer->fixed_key);
len = strlen(prefix);
detailed_signal = g_newa(gchar, len + sizeof("item-changed::")
+ sizeof("/min"));
len += sizeof("item-changed::");
g_stpcpy(g_stpcpy(g_stpcpy(detailed_signal, "item-changed::"), prefix),
"/min");
basic_layer->min_id = connect_swapped_after(layer->data, detailed_signal,
gwy_layer_basic_min_max_changed,
layer);
strcpy(detailed_signal + len, "max");
basic_layer->max_id = connect_swapped_after(layer->data, detailed_signal,
gwy_layer_basic_min_max_changed,
layer);
}
/**
* gwy_math_sym_matrix_invert:
* @n: Matrix size.
* @a: Lower-left part of symmetric, positive definite matrix.
*
* Inverts a positive definite matrix in place.
*
* Returns: Whether the matrix invesion succeeded.
**/
static gboolean
gwy_math_sym_matrix_invert(gint n, gdouble *a)
{
gint q = 0, m;
gdouble s, t;
gdouble *x;
gint k, i, j;
x = g_newa(gdouble, n);
for (k = n-1; k >= 0; k--) {
s = a[0];
if (s <= 0)
return FALSE;
m = 0;
for (i = 0; i < n-1; i++) {
q = m+1;
m += i+2;
t = a[q];
x[i] = -t/s; /* note use temporary x */
if (i >= k)
x[i] = -x[i];
for (j = q; j < m; j++)
a[j - (i+1)] = a[j+1] + t * x[j - q];
}
a[m] = 1.0/s;
for (i = 0; i < n-1; i++)
a[q + i] = x[i];
}
return TRUE;
}
static void _fill_file_md5(const gchar *filename, gint filelen, guint8 *md5)
{
FILE *fp;
guint8 *buffer;
size_t wc;
const gint QQ_MAX_FILE_MD5_LENGTH = 10002432;
g_return_if_fail(filename != NULL && md5 != NULL);
if (filelen > QQ_MAX_FILE_MD5_LENGTH)
filelen = QQ_MAX_FILE_MD5_LENGTH;
fp = g_fopen(filename, "rb");
g_return_if_fail(fp != NULL);
buffer = g_newa(guint8, filelen);
g_return_if_fail(buffer != NULL);
wc = fread(buffer, filelen, 1, fp);
fclose(fp);
if (wc != 1) {
purple_debug_error("qq", "Unable to read file: %s\n", filename);
/* TODO: XXX: Really, the caller should be modified to deal with this properly. */
return;
}
qq_get_md5(md5, QQ_KEY_LENGTH, buffer, filelen);
}
/* parse the return of keep-alive packet, it includes some system information */
void qq_process_keep_alive_reply(guint8 *buf, gint buf_len, GaimConnection *gc)
{
qq_data *qd;
gint len;
gchar **segments;
guint8 *data;
g_return_if_fail(buf != NULL && buf_len != 0);
qd = (qq_data *) gc->proto_data;
len = buf_len;
data = g_newa(guint8, len);
if (qq_crypt(DECRYPT, buf, buf_len, qd->session_key, data, &len)) {
/* the last one is 60, don't know what it is */
if (NULL == (segments = split_data(data, len, "\x1f", 6)))
return;
/* segments[0] and segment[1] are all 0x30 ("0") */
qd->all_online = strtol(segments[2], NULL, 10);
if(0 == qd->all_online)
gaim_connection_error(gc, _("Keep alive error, seems connection lost!"));
g_free(qd->my_ip);
qd->my_ip = g_strdup(segments[3]);
qd->my_port = strtol(segments[4], NULL, 10);
g_strfreev(segments);
} else
gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Error decrypt keep alive reply\n");
/* we refresh buddies's online status periodically */
/* qd->last_get_online is updated when setting get_buddies_online packet */
if ((time(NULL) - qd->last_get_online) >= QQ_UPDATE_ONLINE_INTERVAL)
qq_send_packet_get_buddies_online(gc, QQ_FRIENDS_ONLINE_POSITION_START);
}
/* set seq and is_save2trans, then call send_cmd_detail */
gint qq_send_server_reply(PurpleConnection *gc, guint16 cmd, guint16 seq, guint8 *data, gint data_len)
{
qq_data *qd;
guint8 *encrypted;
gint encrypted_len;
gint bytes_sent;
g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1);
qd = (qq_data *)gc->proto_data;
g_return_val_if_fail(data != NULL && data_len > 0, -1);
#if 1
purple_debug_info("QQ", "<== [SRV-%05d] %s(0x%04X), datalen %d\n",
seq, qq_get_cmd_desc(cmd), cmd, data_len);
#endif
/* at most 17 bytes more */
encrypted = g_newa(guint8, data_len + 17);
encrypted_len = qq_encrypt(encrypted, data, data_len, qd->session_key);
if (encrypted_len < 16) {
purple_debug_error("QQ_ENCRYPT", "Error len %d: [%05d] 0x%04X %s\n",
encrypted_len, seq, cmd, qq_get_cmd_desc(cmd));
return -1;
}
bytes_sent = packet_send_out(gc, cmd, seq, encrypted, encrypted_len);
qq_trans_add_server_reply(gc, cmd, seq, encrypted, encrypted_len);
return bytes_sent;
}
/* data has been encrypted before */
static gint packet_send_out(PurpleConnection *gc, guint16 cmd, guint16 seq, guint8 *data, gint data_len)
{
qq_data *qd;
guint8 *buf;
gint buf_len;
gint bytes_sent;
g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1);
qd = (qq_data *)gc->proto_data;
g_return_val_if_fail(data != NULL && data_len > 0, -1);
buf = g_newa(guint8, MAX_PACKET_SIZE);
memset(buf, 0, MAX_PACKET_SIZE);
/* encapsulate */
buf_len = packet_encap(qd, buf, MAX_PACKET_SIZE, cmd, seq, data, data_len);
if (buf_len <= 0) {
return -1;
}
qd->net_stat.sent++;
if (qd->use_tcp) {
bytes_sent = tcp_send_out(gc, buf, buf_len);
} else {
bytes_sent = udp_send_out(gc, buf, buf_len);
}
return bytes_sent;
}
static gint server_buddy_check_code(PurpleConnection *gc,
gchar *from, guint8 *data, gint data_len)
{
gint bytes;
guint16 code_len;
guint8 *code;
g_return_val_if_fail(data != NULL && data_len > 0, 0);
bytes = 0;
bytes += qq_get16(&code_len, data + bytes);
if (code_len <= 0) {
purple_debug_info("QQ", "Server msg for buddy has no code\n");
return bytes;
}
if (bytes + code_len < data_len) {
purple_debug_error("QQ", "Code len error in server msg for buddy\n");
qq_show_packet("server_buddy_check_code", data, data_len);
code_len = data_len - bytes;
}
code = g_newa(guint8, code_len);
bytes += qq_getdata(code, code_len, data + bytes);
request_buddy_check_code(gc, from, code, code_len);
return bytes;
}
static gint _qq_send_file(PurpleConnection *gc, guint8 *data, gint len, guint16 packet_type, guint32 to_uid)
{
guint8 *raw_data;
gint bytes = 0;
guint32 file_key;
qq_data *qd;
qd = (qq_data *) gc->proto_data;
raw_data = g_newa(guint8, MAX_PACKET_SIZE);
file_key = _gen_file_key();
bytes += qq_put8(raw_data + bytes, packet_type);
bytes += qq_put16(raw_data + bytes, qd->client_tag);
bytes += qq_put8(raw_data + bytes, file_key & 0xff);
bytes += qq_put32(raw_data + bytes, _encrypt_qq_uid(qd->uid, file_key));
bytes += qq_put32(raw_data + bytes, _encrypt_qq_uid(to_uid, file_key));
bytes += qq_putdata(raw_data + bytes, data, len);
if (bytes == len + 12) {
_qq_xfer_write(raw_data, bytes, qd->xfer);
} else
purple_debug_info("QQ", "send_file: want %d but got %d\n", len + 12, bytes);
return bytes;
}
static void _qq_send_file_progess(PurpleConnection *gc)
{
qq_data *qd = (qq_data *) gc->proto_data;
PurpleXfer *xfer = qd->xfer;
ft_info *info = (ft_info *) xfer->data;
guint32 mask;
guint8 *buffer;
guint i;
gint readbytes;
if (purple_xfer_get_bytes_remaining(xfer) <= 0) return;
if (info->window == 0 && info->max_fragment_index == 0)
{
if (_qq_xfer_open_file(purple_xfer_get_local_filename(xfer), "rb", xfer) == -1) {
purple_xfer_cancel_local(xfer);
return;
}
}
buffer = g_newa(guint8, info->fragment_len);
mask = 0x1 << (info->max_fragment_index % sizeof(info->window));
for (i = 0; i < sizeof(info->window); i++) {
if ((info->window & mask) == 0) {
readbytes = _qq_xfer_read_file(buffer, info->max_fragment_index + i, info->fragment_len, xfer);
if (readbytes > 0)
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_DATA_INFO,
info->max_fragment_index + i + 1, 0, buffer, readbytes);
}
if (mask & 0x8000) mask = 0x0001;
else mask = mask << 1;
}
}
/* Encrypt data with session_key, and send packet out */
static gint send_cmd_detail(PurpleConnection *gc, guint16 cmd, guint16 seq,
guint8 *data, gint data_len, gboolean is_save2trans,
UPDCLS update_class, guint32 ship32)
{
qq_data *qd;
guint8 *encrypted;
gint encrypted_len;
gint bytes_sent;
g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1);
qd = (qq_data *)gc->proto_data;
g_return_val_if_fail(data != NULL && data_len > 0, -1);
/* at most 17 bytes more */
encrypted = g_newa(guint8, data_len + 17);
encrypted_len = qq_encrypt(encrypted, data, data_len, qd->session_key);
if (encrypted_len < 16) {
purple_debug_error("QQ_ENCRYPT", "Error len %d: [%05d] 0x%04X %s\n",
encrypted_len, seq, cmd, qq_get_cmd_desc(cmd));
return -1;
}
bytes_sent = packet_send_out(gc, cmd, seq, encrypted, encrypted_len);
if (is_save2trans) {
qq_trans_add_client_cmd(gc, cmd, seq, encrypted, encrypted_len,
update_class, ship32);
}
return bytes_sent;
}
static void
gwy_layer_basic_get_fixed_range(GwyLayerBasic *basic_layer,
GwyContainer *container,
GwyDataField *data_field,
gdouble *rmin,
gdouble *rmax)
{
const gchar *prefix;
gchar *key;
guint len;
if (!basic_layer->fixed_key) {
gwy_data_field_get_min_max(data_field, rmin, rmax);
return;
}
prefix = g_quark_to_string(basic_layer->fixed_key);
len = strlen(prefix);
key = g_newa(gchar, len + sizeof("/min"));
g_stpcpy(g_stpcpy(key, prefix), "/min");
if (!gwy_container_gis_double_by_name(container, key, rmin))
*rmin = gwy_data_field_get_min(data_field);
strcpy(key + len + 1, "max");
if (!gwy_container_gis_double_by_name(container, key, rmax))
*rmax = gwy_data_field_get_max(data_field);
}
void qq_request_get_buddies_level(PurpleConnection *gc, guint32 update_class)
{
qq_data *qd = (qq_data *) gc->proto_data;
PurpleBuddy *buddy;
qq_buddy_data *bd;
guint8 *buf;
GSList *buddies, *it;
gint bytes;
/* server only reply levels for online buddies */
buf = g_newa(guint8, MAX_PACKET_SIZE);
bytes = 0;
bytes += qq_put8(buf + bytes, 0x00);
buddies = purple_find_buddies(purple_connection_get_account(gc), NULL);
for (it = buddies; it; it = it->next) {
buddy = it->data;
if (buddy == NULL) continue;
if (buddy->proto_data == NULL) continue;
bd = (qq_buddy_data *)buddy->proto_data;
if (bd->uid == 0) continue; /* keep me as end of packet*/
if (bd->uid == qd->uid) continue;
bytes += qq_put32(buf + bytes, bd->uid);
}
bytes += qq_put32(buf + bytes, qd->uid);
qq_send_cmd_mess(gc, QQ_CMD_GET_LEVEL, buf, bytes, update_class, 0);
}
static EventdEventsEvent *
_eventd_events_get_event(EventdEvents *self, EventdEvent *event, GQuark *current_flags)
{
const gchar *category, *name;
gsize s;
GList *list;
EventdEventsEvent *match;
category = eventd_event_get_category(event);
name = eventd_event_get_name(event);
s = strlen(category) + strlen(name) + 2;
gchar *full_name = g_newa(gchar, s);
g_snprintf(full_name, s, "%s %s", category, name);
list = g_hash_table_lookup(self->events, full_name);
if ( list != NULL )
{
match = _eventd_events_get_best_match(list, event, current_flags);
if ( match != NULL )
return match;
}
list = g_hash_table_lookup(self->events, category);
if ( list != NULL )
{
match = _eventd_events_get_best_match(list, event, current_flags);
if ( match != NULL )
return match;
}
return NULL;
}
static void
descriptor_check_consistency (Descriptor *desc, gboolean print)
{
int count = desc->anchor.data.count;
int max_count = LOCK_FREE_ALLOC_SB_USABLE_SIZE (desc->block_size) / desc->slot_size;
gboolean* linked = g_newa (gboolean, max_count);
int i, last;
unsigned int index;
#ifndef DESC_AVAIL_DUMMY
Descriptor *avail;
for (avail = desc_avail; avail; avail = avail->next)
g_assert_OR_PRINT (desc != avail, "descriptor is in the available list\n");
#endif
g_assert_OR_PRINT (desc->slot_size == desc->heap->sc->slot_size, "slot size doesn't match size class\n");
if (print)
g_print ("descriptor %p is ", desc);
switch (desc->anchor.data.state) {
case STATE_FULL:
if (print)
g_print ("full\n");
g_assert_OR_PRINT (count == 0, "count is not zero: %d\n", count);
break;
case STATE_PARTIAL:
if (print)
g_print ("partial\n");
g_assert_OR_PRINT (count < max_count, "count too high: is %d but must be below %d\n", count, max_count);
break;
case STATE_EMPTY:
if (print)
g_print ("empty\n");
g_assert_OR_PRINT (count == max_count, "count is wrong: is %d but should be %d\n", count, max_count);
break;
default:
g_assert_OR_PRINT (FALSE, "invalid state\n");
}
for (i = 0; i < max_count; ++i)
linked [i] = FALSE;
index = desc->anchor.data.avail;
last = -1;
for (i = 0; i < count; ++i) {
gpointer addr = (char*)desc->sb + index * desc->slot_size;
g_assert_OR_PRINT (index >= 0 && index < max_count,
"index %d for %dth available slot, linked from %d, not in range [0 .. %d)\n",
index, i, last, max_count);
g_assert_OR_PRINT (!linked [index], "%dth available slot %d linked twice\n", i, index);
if (linked [index])
break;
linked [index] = TRUE;
last = index;
index = *(unsigned int*)addr;
}
}
/**
* gtk_distribute_natural_allocation:
* @extra_space: Extra space to redistribute among children after subtracting
* minimum sizes and any child padding from the overall allocation
* @n_requested_sizes: Number of requests to fit into the allocation
* @sizes: An array of structs with a client pointer and a minimum/natural size
* in the orientation of the allocation.
*
* Distributes @extra_space to child @sizes by bringing smaller
* children up to natural size first.
*
* The remaining space will be added to the @minimum_size member of the
* GtkRequestedSize struct. If all sizes reach their natural size then
* the remaining space is returned.
*
* Returns: The remainder of @extra_space after redistributing space
* to @sizes.
*/
gint
gtk_distribute_natural_allocation (gint extra_space,
guint n_requested_sizes,
GtkRequestedSize *sizes)
{
guint *spreading;
gint i;
g_return_val_if_fail (extra_space >= 0, 0);
spreading = g_newa (guint, n_requested_sizes);
for (i = 0; i < n_requested_sizes; i++)
spreading[i] = i;
/* Distribute the container's extra space c_gap. We want to assign
* this space such that the sum of extra space assigned to children
* (c^i_gap) is equal to c_cap. The case that there's not enough
* space for all children to take their natural size needs some
* attention. The goals we want to achieve are:
*
* a) Maximize number of children taking their natural size.
* b) The allocated size of children should be a continuous
* function of c_gap. That is, increasing the container size by
* one pixel should never make drastic changes in the distribution.
* c) If child i takes its natural size and child j doesn't,
* child j should have received at least as much gap as child i.
*
* The following code distributes the additional space by following
* these rules.
*/
/* Sort descending by gap and position. */
g_qsort_with_data (spreading,
n_requested_sizes, sizeof (guint),
compare_gap, sizes);
/* Distribute available space.
* This master piece of a loop was conceived by Behdad Esfahbod.
*/
for (i = n_requested_sizes - 1; extra_space > 0 && i >= 0; --i)
{
/* Divide remaining space by number of remaining children.
* Sort order and reducing remaining space by assigned space
* ensures that space is distributed equally.
*/
gint glue = (extra_space + i) / (i + 1);
gint gap = sizes[(spreading[i])].natural_size
- sizes[(spreading[i])].minimum_size;
gint extra = MIN (glue, gap);
sizes[spreading[i]].minimum_size += extra;
extra_space -= extra;
}
return extra_space;
}
WatchTreeRemoveResult
watch_tree_remove (WatchTree *tree,
const gchar *path,
gpointer data)
{
WatchTree *root_node = (WatchTree *) tree;
WatchTreeRemoveResult result;
GSList *backtrack;
WatchTree *node;
StringRef ref;
/* '/' */
node = root_node;
ref.str = (gchar *) path;
ref.len = 1;
backtrack = NULL;
while (ref.str[ref.len])
{
GSList *tmp = g_newa (GSList, 1);
tmp->data = node;
tmp->next = backtrack;
backtrack = tmp;
ref.str += ref.len;
ref.len = strcspn (ref.str, "/");
if (ref.str[ref.len] == '/')
ref.len++;
node = tree_node_get_child (node, &ref, FALSE);
g_assert (node != NULL);
}
node->watchers = g_slist_remove (node->watchers, data);
if (node->watchers != NULL)
/* nothing changes */
result = WATCH_TREE_REMOVE_RESULT_NONE;
else if (node->children && g_hash_table_size (node->children))
/* there are still child watches, so we have to check */
result = WATCH_TREE_REMOVE_RESULT_SOME;
else
/* no watchers and no child watches -- remove all */
result = WATCH_TREE_REMOVE_RESULT_ALL;
while (node->watchers == NULL && (!node->children || g_hash_table_size (node->children)) == 0 && backtrack)
{
WatchTree *parent = backtrack->data;
g_hash_table_remove (parent->children, node);
backtrack = backtrack->next;
node = parent;
}
return result;
}
gboolean
peas_lua_utils_check_version (lua_State *L,
guint req_major,
guint req_minor,
guint req_micro)
{
const gchar *version_str;
gchar **version_str_parts;
gint n_version_parts;
gint64 *version_parts;
gint i;
gboolean success = FALSE;
lua_getfield (L, -1, "_VERSION");
version_str = lua_tostring (L, -1);
version_str_parts = g_strsplit (version_str, ".", 0);
n_version_parts = g_strv_length (version_str_parts);
version_parts = g_newa (gint64, n_version_parts);
for (i = 0; i < n_version_parts; ++i)
{
gchar *end;
version_parts[i] = g_ascii_strtoll (version_str_parts[i], &end, 10);
if (*end != '\0' ||
version_parts[i] < 0 ||
version_parts[i] == G_MAXINT64)
{
g_warning ("Invalid version string: %s", version_str);
goto error;
}
}
if (n_version_parts < 3 ||
version_parts[0] != req_major ||
version_parts[1] < req_minor ||
(version_parts[1] == req_minor && version_parts[2] < req_micro))
{
g_warning ("Version mismatch %d.%d.%d is required, found %s",
req_major, req_minor, req_micro, version_str);
goto error;
}
success = TRUE;
error:
/* Pop _VERSION */
lua_pop (L, 1);
g_strfreev (version_str_parts);
return success;
}
static void _qq_update_send_progess(PurpleConnection *gc, guint32 fragment_index)
{
guint32 mask;
guint8 *buffer;
gint readbytes;
qq_data *qd = (qq_data *) gc->proto_data;
PurpleXfer *xfer = qd->xfer;
ft_info *info = (ft_info *) xfer->data;
purple_debug_info("QQ",
"receiving %dth fragment ack, slide window status %o, max_fragment_index %d\n",
fragment_index, info->window, info->max_fragment_index);
if (fragment_index < info->max_fragment_index ||
fragment_index >= info->max_fragment_index + sizeof(info->window)) {
purple_debug_info("QQ", "duplicate %dth fragment, drop it!\n", fragment_index+1);
return;
}
mask = 0x1 << (fragment_index % sizeof(info->window));
if ((info->window & mask) == 0)
{
info->window |= mask;
if (fragment_index + 1 != info->fragment_num) {
xfer->bytes_sent += info->fragment_len;
} else {
xfer->bytes_sent += purple_xfer_get_size(xfer) % info->fragment_len;
}
xfer->bytes_remaining = purple_xfer_get_size(xfer) - purple_xfer_get_bytes_sent(xfer);
purple_xfer_update_progress(xfer);
if (purple_xfer_get_bytes_remaining(xfer) <= 0) {
/* We have finished sending the file */
purple_xfer_set_completed(xfer, TRUE);
return;
}
mask = 0x1 << (info->max_fragment_index % sizeof(info->window));
while (info->window & mask)
{
/* move the slide window */
info->window &= ~mask;
buffer = g_newa(guint8, info->fragment_len);
readbytes = _qq_xfer_read_file(buffer, info->max_fragment_index + sizeof(info->window),
info->fragment_len, xfer);
if (readbytes > 0)
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_DATA_INFO,
info->max_fragment_index + sizeof(info->window) + 1, 0, buffer, readbytes);
info->max_fragment_index ++;
if (mask & 0x8000) mask = 0x0001;
else mask = mask << 1;
}
}
purple_debug_info("QQ",
"procceed %dth fragment ack, slide window status %o, max_fragment_index %d\n",
fragment_index, info->window, info->max_fragment_index);
}
static GimpEevlQuantity
gimp_eevl_factor (GimpEevl *eva)
{
GimpEevlQuantity evaluated_factor = { 0, 0 };
GimpEevlToken consumed_token;
if (gimp_eevl_accept (eva,
GIMP_EEVL_TOKEN_NUM,
&consumed_token))
{
evaluated_factor.value = consumed_token.value.fl;
}
else if (gimp_eevl_accept (eva, '(', NULL))
{
evaluated_factor = gimp_eevl_expression (eva);
gimp_eevl_expect (eva, ')', 0);
}
else
{
gimp_eevl_error (eva, "Expected number or '('");
}
if (eva->current_token.type == GIMP_EEVL_TOKEN_IDENTIFIER)
{
gchar *identifier;
GimpEevlQuantity result;
gimp_eevl_accept (eva,
GIMP_EEVL_TOKEN_ANY,
&consumed_token);
identifier = g_newa (gchar, consumed_token.value.size + 1);
strncpy (identifier, consumed_token.value.c, consumed_token.value.size);
identifier[consumed_token.value.size] = '\0';
if (eva->unit_resolver_proc (identifier,
&result,
eva->data))
{
evaluated_factor.value /= result.value;
evaluated_factor.dimension += result.dimension;
}
else
{
gimp_eevl_error (eva, "Unit was not resolved");
}
}
return evaluated_factor;
}
/* send packet to get info for each group member */
gint qq_request_room_get_members_info( PurpleConnection *gc, guint32 room_id, guint32 update_class, guint32 index )
{
guint8 *raw_data;
gint bytes, num;
GList *list;
qq_room_data *rmd;
qq_buddy_data *bd;
guint32 i = 0;
g_return_val_if_fail(room_id > 0, 0);
rmd = qq_room_data_find(gc, room_id);
g_return_val_if_fail(rmd != NULL, 0);
for (num = 0, list = rmd->members; list != NULL; list = list->next) {
bd = (qq_buddy_data *) list->data;
if (check_update_interval(bd))
num++;
}
if (num <= 0) {
purple_debug_info("QQ", "No group member info needs to be updated now.\n");
return 0;
}
raw_data = g_newa(guint8, 4 * num);
bytes = 0;
list = rmd->members;
/* index shipped from last request
send 30 uids one time */
while (list != NULL) {
if (i>=index)
{
bd = (qq_buddy_data *) list->data;
if (check_update_interval(bd))
bytes += qq_put32(raw_data + bytes, bd->uid);
}
i++;
if (i==index+30) break;
list = list->next;
}
/* if reach the end */
if (list == NULL) i=0;
qq_send_room_cmd_mess(gc, QQ_ROOM_CMD_GET_MEMBERS_INFO, rmd->id, raw_data, bytes,
update_class, i);
return num;
}
static GstFlowReturn
gst_file_sink_render_list (GstBaseSink * bsink, GstBufferList * buffer_list)
{
GstFlowReturn flow;
GstBuffer **buffers;
GstFileSink *sink;
guint8 *mem_nums;
guint total_mems;
guint i, num_buffers;
gboolean sync_after = FALSE;
sink = GST_FILE_SINK_CAST (bsink);
num_buffers = gst_buffer_list_length (buffer_list);
if (num_buffers == 0)
goto no_data;
/* extract buffers from list and count memories */
buffers = g_newa (GstBuffer *, num_buffers);
mem_nums = g_newa (guint8, num_buffers);
for (i = 0, total_mems = 0; i < num_buffers; ++i) {
buffers[i] = gst_buffer_list_get (buffer_list, i);
mem_nums[i] = gst_buffer_n_memory (buffers[i]);
total_mems += mem_nums[i];
if (GST_BUFFER_FLAG_IS_SET (buffers[i], GST_BUFFER_FLAG_SYNC_AFTER))
sync_after = TRUE;
}
flow =
gst_file_sink_render_buffers (sink, buffers, num_buffers, mem_nums,
total_mems);
if (flow == GST_FLOW_OK && sync_after) {
if (fflush (sink->file) || fsync (fileno (sink->file))) {
GST_ELEMENT_ERROR (sink, RESOURCE, WRITE,
(_("Error while writing to file \"%s\"."), sink->filename),
("%s", g_strerror (errno)));
flow = GST_FLOW_ERROR;
}
}
return flow;
no_data:
{
GST_LOG_OBJECT (sink, "empty buffer list");
return GST_FLOW_OK;
}
}
static void
fit_plot_curve(FitArgs *args)
{
GwyGraphCurveModel *cmodel;
gdouble *xd, *yd;
gboolean initial, ok; /* XXX: ignored */
gint i, n;
gdouble *param;
if (!args->is_fitted && !args->is_estimated)
return;
initial = !args->is_fitted;
n = gwy_nlfit_preset_get_nparams(args->fitfunc);
param = g_newa(gdouble, n);
for (i = 0; i < n; i++) {
FitParamArg *arg;
arg = &g_array_index(args->param, FitParamArg, i);
param[i] = initial ? arg->init : arg->value;
}
n = gwy_data_line_get_res(args->xdata);
g_return_if_fail(n == gwy_data_line_get_res(args->ydata));
xd = gwy_data_line_get_data(args->xdata);
yd = gwy_data_line_get_data(args->ydata);
for (i = 0; i < n; i++)
yd[i] = gwy_nlfit_preset_get_value(args->fitfunc, xd[i], param, &ok);
if (gwy_graph_model_get_n_curves(args->graph_model) == 2)
cmodel = gwy_graph_model_get_curve(args->graph_model, 1);
else {
cmodel = gwy_graph_curve_model_new();
g_object_set(cmodel,
"mode", GWY_GRAPH_CURVE_LINE,
"color", &args->fitcolor,
NULL);
gwy_graph_model_add_curve(args->graph_model, cmodel);
g_object_unref(cmodel);
}
g_object_set(cmodel,
"description",
initial
? gwy_sgettext("Estimate")
: gwy_sgettext("Fit"),
NULL);
gwy_graph_curve_model_set_data(cmodel, xd, yd, n);
}
